@nutin/cli 1.3.1 → 2.1.0

package/templates/base/tools/generator/handle-file.js.hbs

@@ -1,12 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import { print{{#if i18n}}, LANGUAGES{{/if}} } from '../utils/index.js';
-{{#if i18n}}
-import { jsonTemplate } from './templates/index.js';
-{{/if}}
-{{#if stylinNutin}}
-import { scssTemplate } from './templates/index.js';
-{{/if}}
+import { print, LANGUAGES } from '../utils/index.js';
+import { localeTemplate } from './templates/index.js';
 
 export function generateFile({
   name,
@@ -16,7 +11,7 @@ export function generateFile({
   extension = 'ts',
 }) {
   fs.mkdirSync(targetPath, { recursive: true });
-  const template = templateFn(name, targetPath);
+  const template = templateFn(name, targetPath, suffix);
   const filePath = `${targetPath}/${name.kebab}.${suffix}.${extension}`;
 
   if (fs.existsSync(filePath)) {
@@ -42,51 +37,29 @@ export function appendToIndex({ name, targetPath, suffix }) {
 
   try {
     fs.appendFileSync(indexFilePath, lineToAppend, 'utf8');
-    print.info(`${suffix}s/index.ts updated.`);
+    print.gray(`${suffix}s/index.ts updated.`);
   } catch (err) {
-    print.error(`Error appending line: ${err}`);
+    throw new Error(`Failed to update ${indexFilePath}: ${err.message}`, { cause: err });
   }
 }
 
-{{#if i18n}}
-export function generateJson({ targetPath, name }) {
+export function generateLocalesJson({ targetPath, name, isView }) {
   const localesDir = `${targetPath}/locales`;
   fs.mkdirSync(localesDir, { recursive: true });
 
-  const template = targetPath.includes('view') ? jsonTemplate(name) : `{ "default": "${name.pascal} works !"}`;
+  const template = localeTemplate(name, isView);
 
-// include "meta" keys for views, empty JSON for components
-  LANGUAGES.forEach((lang) => {
-    fs.writeFileSync(`${localesDir}/${lang}.json`, template);
-  });
-}
-
-{{/if}}
-{{#if stylinNutin}}
-export function generateStylesheet({ name, suffix }) {
-  const template = scssTemplate();
-  const stylesPath = path.join('src', 'styles', `${suffix}s`);
-  const filePath = path.join(stylesPath, `_${name.kebab}.${suffix}.scss`);
-  const indexPath = path.join(stylesPath, `_index.scss`);
-  
-  if (!fs.existsSync(stylesPath) || !fs.existsSync(indexPath)) {
-    print.boldError('Non existing path');
-    process.exit(1);
-  }
-  if (fs.existsSync(filePath)) {
-    print.boldError('A file with this name already exists');
-    process.exit(1);
+  const failedLangs = [];
+  for (const lang of LANGUAGES) {
+    try {
+      fs.writeFileSync(`${localesDir}/${lang}.json`, template);
+    } catch (err) {
+      print.error(`Failed to write locale file for "${lang}": ${err.message}`);
+      failedLangs.push(lang);
+    }
   }
 
-  fs.writeFileSync(filePath, template);
-
-  const lineToAppend = `@forward "${name.kebab}.${suffix}";\n`;
-
-  try {
-    fs.appendFileSync(indexPath, lineToAppend, 'utf8');
-  } catch (err) {
-    print.error(`Error appending line: ${err}`);
+  if (failedLangs.length) {
+    throw new Error(`Failed to generate locale file(s) for: ${failedLangs.join(', ')}`);
   }
 }
-
-{{/if}}

package/templates/base/tools/generator/handle-file.test.js.hbs

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { generateFile, appendToIndex } from './handle-file.js';
+
+describe('handle-file', () => {
+  let tmpDir;
+  let originalCwd;
+  let exitSpy;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-handle-file-'));
+    originalCwd = process.cwd();
+    exitSpy = spyOn(process, 'exit').andCallFake(() => {});
+  });
+
+  afterEach(() => {
+    exitSpy.restore();
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('generateFile writes the template output to <targetPath>/<name>.<suffix>.<extension>', () => {
+    const targetPath = path.join(tmpDir, 'components', 'widget');
+    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
+
+    generateFile({ name, targetPath, templateFn: (n) => `content for ${n.kebab}`, suffix: 'component' });
+
+    const filePath = path.join(targetPath, 'widget.component.ts');
+    expect(fs.existsSync(filePath)).toBeTruthy();
+    expect(fs.readFileSync(filePath, 'utf8')).toBe('content for widget');
+    expect(exitSpy.callCount).toBe(0);
+  });
+
+  it('generateFile respects a custom extension', () => {
+    const targetPath = path.join(tmpDir, 'services', 'widget');
+    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
+
+    generateFile({ name, targetPath, templateFn: () => 'x', suffix: 'service', extension: 'js' });
+
+    expect(fs.existsSync(path.join(targetPath, 'widget.service.js'))).toBeTruthy();
+  });
+
+  it('generateFile calls process.exit(1) instead of overwriting an existing file', () => {
+    const targetPath = path.join(tmpDir, 'components', 'widget');
+    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
+    const templateFn = () => 'fixed content';
+
+    generateFile({ name, targetPath, templateFn, suffix: 'component' });
+    // the second call hits the already-exists guard, which prints via console.error
+    silenceConsole('error', () => generateFile({ name, targetPath, templateFn, suffix: 'component' }));
+
+    expect(exitSpy.callCount).toBe(1);
+    expect(exitSpy.lastCall).toEqual([1]);
+  });
+
+  it('appendToIndex appends an export line to the barrel three segments up from targetPath', () => {
+    process.chdir(tmpDir);
+    const basePath = path.join('src', 'app', 'components');
+    fs.mkdirSync(basePath, { recursive: true });
+    fs.writeFileSync(path.join(basePath, 'index.ts'), "export * from './existing.js';\n");
+
+    const targetPath = path.join('src', 'app', 'components', 'widget');
+    const name = { kebab: 'widget', pascal: 'Widget', camel: 'widget', capitalized: 'Widget' };
+
+    // appendToIndex prints a "index.ts updated" log via console.info
+    silenceConsole('info', () => appendToIndex({ name, targetPath, suffix: 'component' }));
+
+    const indexContent = fs.readFileSync(path.join(basePath, 'index.ts'), 'utf8');
+    expect(indexContent).toBe("export * from './existing.js';\nexport * from './widget/widget.component.js';\n");
+  });
+});

package/templates/base/tools/generator/templates/{component.template.js.hbs → component/component.template.js.hbs}

@@ -1,11 +1,12 @@
-import { getRelToCore } from "../../utils/get-rel-to-core.js";
+import { getRelToCore } from "../../../utils/get-rel-to-core.js";
 
 export const componentTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
+  const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
   return `import { Component } from '${relToCore}';
 
-const templateFn = () => {{#if template}}\`__TEMPLATE_PLACEHOLDER__\`{{else}}\`<div>${name.pascal} works !</div>\`{{/if}};
+const templateFn = () => \`${htmlTemplate}\`;
 
 export class ${name.pascal}Component extends Component {
   constructor(mountTarget: HTMLElement) {

package/templates/base/tools/generator/templates/component/component.template.test.js.hbs

@@ -0,0 +1,23 @@
+import { componentTemplate } from './component.template.js';
+
+describe('componentTemplate', () => {
+  it('renders a component class importing Component via the relative core path', () => {
+    const name = { pascal: 'Widget' };
+    const targetPath = 'src/app/components/widget';
+
+    // The generator always leaves the html body as a placeholder — the builder
+    // swaps in the .html sibling's content at build time.
+    expect(componentTemplate(name, targetPath)).toBe(
+      `import { Component } from '../../../core/index.js';
+
+const templateFn = () => \`__TEMPLATE_PLACEHOLDER__\`;
+
+export class WidgetComponent extends Component {
+  constructor(mountTarget: HTMLElement) {
+    super({templateFn, mountTarget});
+  }
+}
+`
+    );
+  });
+});

package/templates/base/tools/generator/templates/html/html.template.js.hbs

@@ -0,0 +1,2 @@
+export const htmlTemplate = (name) => `<div>${name.pascal} works !</div>
+`;

package/templates/base/tools/generator/templates/html/html.template.test.js.hbs

@@ -0,0 +1,7 @@
+import { htmlTemplate } from './html.template.js';
+
+describe('htmlTemplate', () => {
+  it('renders a placeholder div with the component/view name', () => {
+    expect(htmlTemplate({ pascal: 'Widget' })).toBe('<div>Widget works !</div>\n');
+  });
+});

package/templates/base/tools/generator/templates/index.js.hbs

@@ -1,12 +1,7 @@
-export * from './component.template.js';
-export * from './view.template.js';
-export * from './service.template.js';
-{{#if template}}
-export * from './html.template.js';
-{{/if}}
-{{#if i18n}}
-export * from './json.template.js';
-{{/if}}
-{{#if stylinNutin}}
-export * from './scss.template.js';
-{{/if}}
+export * from './component/component.template.js';
+export * from './view/view.template.js';
+export * from './service/service.template.js';
+export * from './locale/locale.template.js';
+export * from './scss/scss.template.js';
+export * from './html/html.template.js';
+export * from './test/test.template.js';

package/templates/base/tools/generator/templates/locale/locale.template.js.hbs

@@ -0,0 +1,8 @@
+export const localeTemplate = (name, isView) => isView ? `{
+  "title": "${name.capitalized}",
+  "default": "${name.pascal} works !"
+}
+` : `{
+  "default": "${name.pascal} works !"
+}
+`;

package/templates/base/tools/generator/templates/locale/locale.template.test.js.hbs

@@ -0,0 +1,17 @@
+import { localeTemplate } from './locale.template.js';
+
+describe('localeTemplate', () => {
+  it('renders a locale JSON stub with a "default" key', () => {
+    expect(localeTemplate({ pascal: 'Widget', capitalized: 'Widget' })).toBe('{\n  "default": "Widget works !"\n}\n');
+  });
+
+  it('does not include a "title" key when isView is false', () => {
+    expect(localeTemplate({ pascal: 'Widget', capitalized: 'Widget' }, false)).toBe('{\n  "default": "Widget works !"\n}\n');
+  });
+
+  it('includes a top-level "title" key seeded from the capitalized name when isView is true', () => {
+    expect(localeTemplate({ pascal: 'Widget', capitalized: 'Widget' }, true)).toBe(
+      '{\n  "title": "Widget",\n  "default": "Widget works !"\n}\n'
+    );
+  });
+});

package/templates/base/tools/generator/templates/scss/scss.template.js.hbs

@@ -0,0 +1 @@
+export const scssTemplate = () => `\n`;

package/templates/base/tools/generator/templates/scss/scss.template.test.js.hbs

@@ -0,0 +1,7 @@
+import { scssTemplate } from './scss.template.js';
+
+describe('scssTemplate', () => {
+  it('renders an empty stylesheet placeholder', () => {
+    expect(scssTemplate()).toBe('\n');
+  });
+});

package/templates/base/tools/generator/templates/service/service.template.js.hbs

@@ -0,0 +1,17 @@
+import { getRelToCore } from "../../../utils/get-rel-to-core.js";
+
+export const serviceTemplate = (name, targetPath) => {
+  const relToCore = getRelToCore(targetPath);
+
+  return `import { Service } from '${relToCore}';
+
+export class ${name.pascal}Service extends Service<${name.pascal}Service> {  
+  constructor() {
+    super();
+  }
+
+}
+
+export const ${name.camel}Service = ${name.pascal}Service.getInstance();
+`;
+}

package/templates/base/tools/generator/templates/service/service.template.test.js.hbs

@@ -0,0 +1,22 @@
+import { serviceTemplate } from './service.template.js';
+
+describe('serviceTemplate', () => {
+  it('renders a Service subclass with a singleton export, importing Service via the relative core path', () => {
+    const name = { pascal: 'Widget', camel: 'widget' };
+    const targetPath = 'src/app/components/widget';
+
+    expect(serviceTemplate(name, targetPath)).toBe(
+      `import { Service } from '../../../core/index.js';
+
+export class WidgetService extends Service<WidgetService> {  
+  constructor() {
+    super();
+  }
+
+}
+
+export const widgetService = WidgetService.getInstance();
+`
+    );
+  });
+});

package/templates/base/tools/generator/templates/test/test.template.js.hbs

@@ -0,0 +1,10 @@
+export const testTemplate = (name, targetPath, suffix) => {
+  const type = suffix.charAt(0).toUpperCase() + suffix.slice(1);
+
+  return `import { ${name.pascal}${type} } from '#root/dist/${targetPath}/${name.kebab}.${suffix}.js';
+
+describe('${name.pascal}${type}', () => {
+  it.todo('Write tests for ${name.pascal}${type}');
+});
+`;
+}

package/templates/base/tools/generator/templates/test/test.template.test.js.hbs

@@ -0,0 +1,27 @@
+import { testTemplate } from './test.template.js';
+
+describe('testTemplate', () => {
+  it('renders an it.todo stub importing the built output via #root/dist', () => {
+    const name = { pascal: 'Widget', kebab: 'widget' };
+    const targetPath = 'src/app/components/widget';
+
+    expect(testTemplate(name, targetPath, 'component')).toBe(
+      `import { WidgetComponent } from '#root/dist/src/app/components/widget/widget.component.js';
+
+describe('WidgetComponent', () => {
+  it.todo('Write tests for WidgetComponent');
+});
+`
+    );
+  });
+
+  it('capitalizes only the first letter of the suffix for the "Type" suffix on the class name', () => {
+    const name = { pascal: 'Home', kebab: 'home' };
+    const targetPath = 'src/app/views/home';
+
+    const result = testTemplate(name, targetPath, 'view');
+
+    expect(result).toContain('HomeView');
+    expect(result).toContain("it.todo('Write tests for HomeView');");
+  });
+});

package/templates/base/tools/generator/templates/{view.template.js.hbs → view/view.template.js.hbs}

@@ -1,15 +1,16 @@
-import { getRelToCore } from "../../utils/get-rel-to-core.js";
+import { getRelToCore } from "../../../utils/get-rel-to-core.js";
 
 export const viewTemplate = (name, targetPath) => {
   const relToCore = getRelToCore(targetPath);
+  const htmlTemplate = '__TEMPLATE_PLACEHOLDER__';
 
   return `import { View } from '${relToCore}';
 
-const template = {{#if template}}\`__TEMPLATE_PLACEHOLDER__\`{{else}}\`<div>${name.pascal} works !</div>\`{{/if}};
+const template = \`${htmlTemplate}\`;
 
 export class ${name.pascal}View extends View {
   constructor() {
-    super({template});
+    super({ template, viewName: '${name.kebab}' });
   }
 
 }

package/templates/base/tools/generator/templates/view/view.template.test.js.hbs

@@ -0,0 +1,24 @@
+import { viewTemplate } from './view.template.js';
+
+describe('viewTemplate', () => {
+  it('renders a view class importing View via the relative core path', () => {
+    const name = { kebab: 'widget', pascal: 'Widget' };
+    const targetPath = 'src/app/components/widget';
+
+    // The generator always leaves the html body as a placeholder — the builder
+    // swaps in the .html sibling's content at build time.
+    expect(viewTemplate(name, targetPath)).toBe(
+      `import { View } from '../../../core/index.js';
+
+const template = \`__TEMPLATE_PLACEHOLDER__\`;
+
+export class WidgetView extends View {
+  constructor() {
+    super({ template, viewName: 'widget' });
+  }
+
+}
+`
+    );
+  });
+});

package/templates/base/tools/testin-nutin/core/coverage/collect-coverage.js.hbs

@@ -0,0 +1,39 @@
+import { Session } from 'node:inspector/promises';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { errorExit } from '../../../utils/index.js';
+
+let session;
+
+export async function startCoverage() {
+  try {
+    session = new Session();
+    session.connect();
+    await session.post('Profiler.enable');
+    await session.post('Profiler.startPreciseCoverage', { callCount: true, detailed: true });
+  } catch (err) {
+    errorExit(err, 'coverage/start');
+  }
+}
+
+export async function stopCoverage(scopedDirs) {
+  let result;
+  try {
+    ({ result } = await session.post('Profiler.takePreciseCoverage'));
+    await session.post('Profiler.stopPreciseCoverage');
+    await session.post('Profiler.disable');
+    session.disconnect();
+  } catch (err) {
+    errorExit(err, 'coverage/stop');
+  }
+
+  return result
+    .filter(entry => entry.url.startsWith('file://'))
+    .map(entry => ({ ...entry, filePath: fileURLToPath(entry.url) }))
+    .filter(({ filePath }) => {
+      const rel = path.relative(process.cwd(), filePath);
+      if (rel.includes(`node_modules${path.sep}`)) return false;
+      if (rel.endsWith('.test.js')) return false;
+      return scopedDirs.some(dir => rel.startsWith(dir + path.sep));
+    });
+}

package/templates/base/tools/testin-nutin/core/coverage/compute-coverage.js.hbs

@@ -0,0 +1,115 @@
+import fs from 'fs';
+import path from 'path';
+import { errorExit } from '../../../utils/index.js';
+
+// V8 ranges within a script are always disjoint or strictly nested, never partially
+// overlapping. The smallest range containing an offset holds the true execution count
+// for that offset - e.g. "this function ran 5x but this one branch inside it ran 0x".
+function countAt(offset, ranges) {
+  let best = null;
+  for (const range of ranges) {
+    if (offset < range.startOffset || offset >= range.endOffset) continue;
+    if (!best || (range.endOffset - range.startOffset) < (best.endOffset - best.startOffset)) {
+      best = range;
+    }
+  }
+  return best ? best.count : 0;
+}
+
+function buildLineStarts(sourceText) {
+  const starts = [0];
+  for (let i = 0; i < sourceText.length; i++) {
+    if (sourceText[i] === '\n') starts.push(i + 1);
+  }
+  return starts;
+}
+
+function offsetToLine(offset, lineStarts) {
+  let lo = 0, hi = lineStarts.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1;
+    if (lineStarts[mid] <= offset) lo = mid; else hi = mid - 1;
+  }
+  return lo + 1; // 1-indexed
+}
+
+// V8 sometimes reports an empty functionName (e.g. accessors, unnamed callbacks).
+// Fall back to reading the source at the function's own start offset instead of a
+// meaningless placeholder - covers `constructor(`, `get foo(`, method names, etc.
+// Only treat a leading identifier as a real name when it's immediately followed by
+// `(` (a param list) - otherwise it's just an arrow function's bare parameter (e.g.
+// `c => ...`), which isn't a name at all, so fall through to a source snippet instead.
+function deriveLabel(sourceText, startOffset) {
+  const snippet = sourceText.slice(startOffset, startOffset + 60);
+  const named = snippet.match(/^\s*(?:get |set )?([A-Za-z_$][\w$]*)\s*\(/);
+  if (named) return named[1];
+  return snippet.trim().split('\n')[0].slice(0, 30) || '<anonymous>';
+}
+
+export function computeFileCoverage({ functions }, sourceText) {
+  const allRanges = functions.flatMap(fn => fn.ranges);
+  const lineStarts = buildLineStarts(sourceText);
+
+  // Line coverage: sample the count at each line's first non-whitespace character.
+  // Not statement/branch-accurate, but simple and good enough for a lightweight report.
+  let offset = 0;
+  let totalLines = 0;
+  let coveredLines = 0;
+  const uncoveredLines = [];
+  for (const line of sourceText.split('\n')) {
+    const firstChar = line.search(/\S/);
+    if (firstChar !== -1) {
+      totalLines++;
+      if (countAt(offset + firstChar, allRanges) > 0) coveredLines++;
+      else uncoveredLines.push(offsetToLine(offset + firstChar, lineStarts));
+    }
+    offset += line.length + 1;
+  }
+
+  // Function coverage: every functions[] entry except the whole-script pseudo-function,
+  // identified by its first range spanning the entire file.
+  const realFunctions = functions.filter(fn => {
+    const [topRange] = fn.ranges;
+    return !(topRange.startOffset === 0 && topRange.endOffset === sourceText.length);
+  });
+  const coveredFunctions = realFunctions.filter(fn => fn.ranges[0].count > 0).length;
+  const uncoveredFunctions = realFunctions
+    .filter(fn => fn.ranges[0].count === 0)
+    .map(fn => ({
+      name: fn.functionName || deriveLabel(sourceText, fn.ranges[0].startOffset),
+      line: offsetToLine(fn.ranges[0].startOffset, lineStarts),
+    }));
+
+  // Branch coverage: every range beyond a function's own top-level range (index 0)
+  // is a nested conditional block V8 already tracked while collecting detailed
+  // coverage - if/else arms, ternary branches, switch cases, logical short-circuits,
+  // loop bodies. No AST parsing needed, just reusing data already being collected.
+  const allBranchRanges = functions.flatMap(fn => fn.ranges.slice(1));
+  const coveredBranches = allBranchRanges.filter(r => r.count > 0).length;
+  const uncoveredBranches = allBranchRanges
+    .filter(r => r.count === 0)
+    .map(r => offsetToLine(r.startOffset, lineStarts))
+    .sort((a, b) => a - b);
+
+  return {
+    totalLines, coveredLines, uncoveredLines,
+    linesPct: totalLines ? (coveredLines / totalLines) * 100 : 100,
+    totalBranches: allBranchRanges.length, coveredBranches, uncoveredBranches,
+    branchesPct: allBranchRanges.length ? (coveredBranches / allBranchRanges.length) * 100 : 100,
+    totalFunctions: realFunctions.length, coveredFunctions, uncoveredFunctions,
+    functionsPct: realFunctions.length ? (coveredFunctions / realFunctions.length) * 100 : 100,
+  };
+}
+
+export function buildCoverageReport(scopedResults) {
+  return scopedResults.map(entry => {
+    let sourceText;
+    try {
+      sourceText = fs.readFileSync(entry.filePath, 'utf-8');
+    } catch (err) {
+      errorExit(err, 'coverage/compute-coverage');
+    }
+    const coverage = computeFileCoverage(entry, sourceText);
+    return { file: path.relative(process.cwd(), entry.filePath), ...coverage };
+  });
+}

package/templates/base/tools/testin-nutin/core/coverage/compute-coverage.test.js.hbs

@@ -0,0 +1,74 @@
+import { computeFileCoverage } from './compute-coverage.js';
+
+describe('computeFileCoverage', () => {
+  it('reports 100% when every function and line ran', () => {
+    const sourceText = 'function covered() {\n  return 1;\n}\n';
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        { functionName: 'covered', ranges: [{ startOffset: 0, endOffset: sourceText.length - 1, count: 3 }] },
+      ],
+    };
+
+    const { linesPct, functionsPct, branchesPct } = computeFileCoverage(scriptResult, sourceText);
+    expect(linesPct).toEqual(100);
+    expect(functionsPct).toEqual(100);
+    expect(branchesPct).toEqual(100); // no nested ranges anywhere -> defaults to 100
+  });
+
+  it('reports 0% for a function that never ran', () => {
+    const sourceText = 'function uncovered() {\n  return 1;\n}\n';
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        { functionName: 'uncovered', ranges: [{ startOffset: 0, endOffset: sourceText.length - 1, count: 0 }] },
+      ],
+    };
+
+    const { linesPct, functionsPct } = computeFileCoverage(scriptResult, sourceText);
+    expect(linesPct).toEqual(0);
+    expect(functionsPct).toEqual(0);
+  });
+
+  it('lets a nested 0-count branch override its enclosing covered range', () => {
+    const sourceText = 'function branchy(flag) {\n  if (flag) {\n    return 1;\n  }\n  return 2;\n}\n';
+    const branchStart = sourceText.indexOf('return 1');
+    const branchEnd = sourceText.indexOf(';', branchStart) + 1;
+
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        {
+          functionName: 'branchy',
+          ranges: [
+            { startOffset: 0, endOffset: sourceText.length - 1, count: 5 },
+            { startOffset: branchStart, endOffset: branchEnd, count: 0 },
+          ],
+        },
+      ],
+    };
+
+    const { linesPct, totalBranches, coveredBranches, branchesPct } = computeFileCoverage(scriptResult, sourceText);
+    // every line covered except the never-taken "return 1;" branch
+    expect(linesPct).toEqual(5 / 6 * 100);
+    expect(totalBranches).toEqual(1);
+    expect(coveredBranches).toEqual(0);
+    expect(branchesPct).toEqual(0);
+  });
+
+  it('derives a name from the source when V8 reports an empty functionName', () => {
+    const sourceText = 'class Foo {\n  constructor(x) {\n    this.x = x;\n  }\n}\n';
+    const constructorStart = sourceText.indexOf('constructor');
+    const constructorEnd = sourceText.indexOf('}', constructorStart) + 1;
+
+    const scriptResult = {
+      functions: [
+        { functionName: '', ranges: [{ startOffset: 0, endOffset: sourceText.length, count: 1 }] },
+        { functionName: '', ranges: [{ startOffset: constructorStart, endOffset: constructorEnd, count: 0 }] },
+      ],
+    };
+
+    const { uncoveredFunctions } = computeFileCoverage(scriptResult, sourceText);
+    expect(uncoveredFunctions).toEqual([{ name: 'constructor', line: 2 }]);
+  });
+});