@shipload/item-renderer 0.2.2 → 0.2.3

package/test/render.test.ts

@@ -1,40 +1,43 @@
-import { expect, test } from 'bun:test'
-import { resolveItem } from '@shipload/sdk'
-import { renderItem, renderFromPayload } from '../src/render.ts'
-import { RenderError } from '../src/errors.ts'
-import { encodePayload } from '../src/payload/codec.ts'
-import { FIXTURES } from './fixtures/cargo-items.ts'
+import { expect, test } from "bun:test";
+import { resolveItem } from "@shipload/sdk";
+import { renderItem, renderFromPayload } from "../src/render.ts";
+import { RenderError } from "../src/errors.ts";
+import { encodePayload } from "../src/payload/codec.ts";
+import { FIXTURES } from "./fixtures/cargo-items.ts";
 
-test('renderItem dispatches to resource template for resources', () => {
-  const item = FIXTURES.oreT1
-  const resolved = resolveItem(item.item_id, item.stats, item.modules)
-  const svg = renderItem(item, resolved)
-  expect(svg).toContain('Crude Ore')
-})
+test("renderItem dispatches to resource template for resources", () => {
+  const item = FIXTURES.oreT1;
+  const resolved = resolveItem(item.item_id, item.stats, item.modules);
+  const svg = renderItem(item, resolved);
+  expect(svg).toContain("Crude Ore");
+});
 
-test('renderItem dispatches to packed entity template for entities', () => {
-  const item = FIXTURES.shipT1TwoModules
-  const resolved = resolveItem(item.item_id, item.stats, item.modules)
-  const svg = renderItem(item, resolved)
-  expect(svg).toContain('HULL')
-})
+test("renderItem dispatches to packed entity template for entities", () => {
+  const item = FIXTURES.shipT1TwoModules;
+  const resolved = resolveItem(item.item_id, item.stats, item.modules);
+  const svg = renderItem(item, resolved);
+  expect(svg).toContain("HULL");
+});
 
-test('renderItem dispatches to module template for modules', () => {
-  const item = FIXTURES.engineT1
-  const resolved = resolveItem(item.item_id, item.stats, item.modules)
-  const svg = renderItem(item, resolved)
-  expect(svg).toContain('MODULE')
-})
+test("renderItem dispatches to module template for modules", () => {
+  const item = FIXTURES.engineT1;
+  const resolved = resolveItem(item.item_id, item.stats, item.modules);
+  const svg = renderItem(item, resolved);
+  expect(svg).toContain("MODULE");
+});
 
-test('renderItem throws RenderError for unknown types', () => {
-  const item = FIXTURES.oreT1
-  const fake = { ...resolveItem(item.item_id, item.stats, item.modules), itemType: 'unknown' as never }
-  expect(() => renderItem(item, fake)).toThrow(RenderError)
-})
+test("renderItem throws RenderError for unknown types", () => {
+  const item = FIXTURES.oreT1;
+  const fake = {
+    ...resolveItem(item.item_id, item.stats, item.modules),
+    itemType: "unknown" as never,
+  };
+  expect(() => renderItem(item, fake)).toThrow(RenderError);
+});
 
-test('renderFromPayload round-trips a payload into SVG', async () => {
-  const payload = encodePayload(FIXTURES.oreT1)
-  const { svg, item } = await renderFromPayload(payload)
-  expect(svg).toContain('Crude Ore')
-  expect(item.itemType).toBe('resource')
-})
+test("renderFromPayload round-trips a payload into SVG", async () => {
+  const payload = encodePayload(FIXTURES.oreT1);
+  const { svg, item } = await renderFromPayload(payload);
+  expect(svg).toContain("Crude Ore");
+  expect(item.itemType).toBe("resource");
+});

package/test/sanity.test.ts

@@ -1,6 +1,6 @@
-import { expect, test } from 'bun:test'
-import { VERSION } from '../src/index.ts'
+import { expect, test } from "bun:test";
+import { VERSION } from "../src/index.ts";
 
-test('VERSION is a semver string', () => {
-  expect(VERSION).toMatch(/^\d+\.\d+\.\d+$/)
-})
+test("VERSION is a semver string", () => {
+  expect(VERSION).toMatch(/^\d+\.\d+\.\d+$/);
+});

package/test/sdk-link.test.ts

@@ -1,19 +1,19 @@
-import { expect, test } from 'bun:test'
-import { resolveItem, ServerContract, type ResolvedItem } from '@shipload/sdk'
+import { expect, test } from "bun:test";
+import { resolveItem, ServerContract, type ResolvedItem } from "@shipload/sdk";
 
-test('sdkv2 is linked and exposes resolveItem + ResolvedItem type', () => {
-  const resolved: ResolvedItem = resolveItem(101 /* T1 Ore */, undefined, undefined)
-  expect(resolved.itemId).toBe(101)
-  expect(resolved.category).toBe('ore')
-  expect(resolved.itemType).toBe('resource')
-})
+test("sdkv2 is linked and exposes resolveItem + ResolvedItem type", () => {
+  const resolved: ResolvedItem = resolveItem(101 /* T1 Ore */, undefined, undefined);
+  expect(resolved.itemId).toBe(101);
+  expect(resolved.category).toBe("ore");
+  expect(resolved.itemType).toBe("resource");
+});
 
-test('ServerContract.Types.cargo_item can be constructed', () => {
+test("ServerContract.Types.cargo_item can be constructed", () => {
   const ci = ServerContract.Types.cargo_item.from({
     item_id: 101,
     quantity: 1,
-    stats: '0',
+    stats: "0",
     modules: [],
-  })
-  expect(ci.item_id.equals(101)).toBe(true)
-})
+  });
+  expect(ci.item_id.equals(101)).toBe(true);
+});

package/test/svg.test.ts

@@ -1,28 +1,30 @@
-import { expect, test } from 'bun:test'
-import { attr, el, escapeXml } from '../src/primitives/svg.ts'
+import { expect, test } from "bun:test";
+import { attr, el, escapeXml } from "../src/primitives/svg.ts";
 
-test('escapeXml escapes the five XML entity chars', () => {
+test("escapeXml escapes the five XML entity chars", () => {
   expect(escapeXml(`5 > 3 & 2 < 4 "hi" 'yo'`)).toBe(
-    '5 &gt; 3 &amp; 2 &lt; 4 &quot;hi&quot; &apos;yo&apos;',
-  )
-})
+    "5 &gt; 3 &amp; 2 &lt; 4 &quot;hi&quot; &apos;yo&apos;",
+  );
+});
 
-test('attr emits name=value pairs with quoted values', () => {
-  expect(attr({ width: 10, height: 20, fill: '#123456' }))
-    .toBe(' width="10" height="20" fill="#123456"')
-})
+test("attr emits name=value pairs with quoted values", () => {
+  expect(attr({ width: 10, height: 20, fill: "#123456" })).toBe(
+    ' width="10" height="20" fill="#123456"',
+  );
+});
 
-test('attr drops undefined and null values', () => {
-  expect(attr({ width: 10, height: undefined, stroke: null as unknown as string }))
-    .toBe(' width="10"')
-})
+test("attr drops undefined and null values", () => {
+  expect(attr({ width: 10, height: undefined, stroke: null as unknown as string })).toBe(
+    ' width="10"',
+  );
+});
 
-test('attr escapes special chars in values', () => {
-  expect(attr({ label: `ship "fast"` })).toBe(' label="ship &quot;fast&quot;"')
-})
+test("attr escapes special chars in values", () => {
+  expect(attr({ label: `ship "fast"` })).toBe(' label="ship &quot;fast&quot;"');
+});
 
-test('el builds self-closing and wrapping elements', () => {
-  expect(el('rect', { width: 10, height: 10 })).toBe('<rect width="10" height="10"/>')
-  expect(el('g', {}, '<rect/><rect/>')).toBe('<g><rect/><rect/></g>')
-  expect(el('text', { x: 5 }, 'hi')).toBe('<text x="5">hi</text>')
-})
+test("el builds self-closing and wrapping elements", () => {
+  expect(el("rect", { width: 10, height: 10 })).toBe('<rect width="10" height="10"/>');
+  expect(el("g", {}, "<rect/><rect/>")).toBe("<g><rect/><rect/></g>");
+  expect(el("text", { x: 5 }, "hi")).toBe('<text x="5">hi</text>');
+});

package/test/templates-component.test.ts

@@ -1,36 +1,36 @@
-import { expect, test } from 'bun:test'
-import { resolveItem } from '@shipload/sdk'
-import { renderComponent } from '../src/templates/component.ts'
-import { FIXTURES } from './fixtures/cargo-items.ts'
+import { expect, test } from "bun:test";
+import { resolveItem } from "@shipload/sdk";
+import { renderComponent } from "../src/templates/component.ts";
+import { FIXTURES } from "./fixtures/cargo-items.ts";
 
-test('matches the committed Hull Plates snapshot', async () => {
-  const item = FIXTURES.hullPlates
-  const resolved = resolveItem(item.item_id, item.stats, item.modules)
-  const svg = renderComponent(item, resolved)
-  expect(svg).toMatchSnapshot('component-hull-plates.svg')
-})
+test("matches the committed Hull Plates snapshot", async () => {
+  const item = FIXTURES.hullPlates;
+  const resolved = resolveItem(item.item_id, item.stats, item.modules);
+  const svg = renderComponent(item, resolved);
+  expect(svg).toMatchSnapshot("component-hull-plates.svg");
+});
 
-test('renderComponent ranges mode shows stat abbreviations with no values', () => {
-  const item = FIXTURES.hullPlates
-  const resolved = resolveItem(item.item_id)
-  const svg = renderComponent(item, resolved, { mode: 'ranges' })
-  expect(svg).toContain('STR')
-  expect(svg).toContain('DEN')
-  expect(svg).not.toMatch(/>\d{3}<\/text>/)
-  expect(svg).toContain('COMPONENT')
-  expect(svg).toContain('Mass')
-})
+test("renderComponent ranges mode shows stat abbreviations with no values", () => {
+  const item = FIXTURES.hullPlates;
+  const resolved = resolveItem(item.item_id);
+  const svg = renderComponent(item, resolved, { mode: "ranges" });
+  expect(svg).toContain("STR");
+  expect(svg).toContain("DEN");
+  expect(svg).not.toMatch(/>\d{3}<\/text>/);
+  expect(svg).toContain("COMPONENT");
+  expect(svg).toContain("Mass");
+});
 
-test('renderComponent values mode (default) still shows concrete numbers', () => {
-  const item = FIXTURES.hullPlates
-  const resolved = resolveItem(item.item_id, item.stats)
-  const svg = renderComponent(item, resolved)
-  expect(svg).toMatch(/>\d+<\/text>/)
-})
+test("renderComponent values mode (default) still shows concrete numbers", () => {
+  const item = FIXTURES.hullPlates;
+  const resolved = resolveItem(item.item_id, item.stats);
+  const svg = renderComponent(item, resolved);
+  expect(svg).toMatch(/>\d+<\/text>/);
+});
 
-test('renderComponent ranges mode matches snapshot', () => {
-  const item = FIXTURES.hullPlates
-  const resolved = resolveItem(item.item_id)
-  const svg = renderComponent(item, resolved, { mode: 'ranges' })
-  expect(svg).toMatchSnapshot('component-ranges')
-})
+test("renderComponent ranges mode matches snapshot", () => {
+  const item = FIXTURES.hullPlates;
+  const resolved = resolveItem(item.item_id);
+  const svg = renderComponent(item, resolved, { mode: "ranges" });
+  expect(svg).toMatchSnapshot("component-ranges");
+});

package/test/templates-dispatch.test.ts

@@ -1,35 +1,35 @@
-import { test, expect } from 'bun:test'
-import { resolveItem } from '@shipload/sdk'
-import { renderByType } from '../src/templates/index.ts'
-import { FIXTURES } from './fixtures/cargo-items.ts'
+import { test, expect } from "bun:test";
+import { resolveItem } from "@shipload/sdk";
+import { renderByType } from "../src/templates/index.ts";
+import { FIXTURES } from "./fixtures/cargo-items.ts";
 
-test('renderByType forwards mode=ranges to resource template', () => {
-  const item = FIXTURES.oreT1
-  const resolved = resolveItem(item.item_id)
-  const svg = renderByType(item, resolved, { mode: 'ranges' })
+test("renderByType forwards mode=ranges to resource template", () => {
+  const item = FIXTURES.oreT1;
+  const resolved = resolveItem(item.item_id);
+  const svg = renderByType(item, resolved, { mode: "ranges" });
   // No 3-digit stat values
-  expect(svg).not.toMatch(/>\d{3,}<\/text>/)
-})
+  expect(svg).not.toMatch(/>\d{3,}<\/text>/);
+});
 
-test('renderByType forwards mode=ranges to component template', () => {
-  const item = FIXTURES.hullPlates
-  const resolved = resolveItem(item.item_id)
-  const svg = renderByType(item, resolved, { mode: 'ranges' })
-  expect(svg).not.toMatch(/>\d{3,}<\/text>/)
-  expect(svg).toContain('COMPONENT')
-})
+test("renderByType forwards mode=ranges to component template", () => {
+  const item = FIXTURES.hullPlates;
+  const resolved = resolveItem(item.item_id);
+  const svg = renderByType(item, resolved, { mode: "ranges" });
+  expect(svg).not.toMatch(/>\d{3,}<\/text>/);
+  expect(svg).toContain("COMPONENT");
+});
 
-test('renderByType forwards mode=ranges to module template', () => {
-  const item = FIXTURES.engineT1
-  const resolved = resolveItem(item.item_id)
-  const svg = renderByType(item, resolved, { mode: 'ranges' })
-  expect(svg).toContain('MODULE')
-})
+test("renderByType forwards mode=ranges to module template", () => {
+  const item = FIXTURES.engineT1;
+  const resolved = resolveItem(item.item_id);
+  const svg = renderByType(item, resolved, { mode: "ranges" });
+  expect(svg).toContain("MODULE");
+});
 
-test('renderByType default mode is values (no opts)', () => {
-  const item = FIXTURES.oreT1
-  const resolved = resolveItem(item.item_id, item.stats)
-  const svg = renderByType(item, resolved)
+test("renderByType default mode is values (no opts)", () => {
+  const item = FIXTURES.oreT1;
+  const resolved = resolveItem(item.item_id, item.stats);
+  const svg = renderByType(item, resolved);
   // At least one numeric stat value
-  expect(svg).toMatch(/>\d+<\/text>/)
-})
+  expect(svg).toMatch(/>\d+<\/text>/);
+});

package/test/templates-item-cell.test.ts

@@ -1,94 +1,94 @@
-import { test, expect } from 'bun:test'
-import { resolveItem } from '@shipload/sdk'
-import { ITEM_HULL_PLATES, ITEM_ENGINE_T1, ITEM_SHIP_T1_PACKED } from '@shipload/sdk'
-import { renderItemCell, itemCellGroup } from '../src/templates/item-cell.ts'
+import { test, expect } from "bun:test";
+import { resolveItem } from "@shipload/sdk";
+import { ITEM_HULL_PLATES, ITEM_ENGINE_T1, ITEM_SHIP_T1_PACKED } from "@shipload/sdk";
+import { renderItemCell, itemCellGroup } from "../src/templates/item-cell.ts";
 
-test('renderItemCell returns a self-contained <svg>', () => {
-  const resolved = resolveItem(ITEM_HULL_PLATES)
-  const svg = renderItemCell({ resolved, size: 48 })
-  expect(svg.startsWith('<svg ')).toBe(true)
-  expect(svg).toContain('viewBox="0 0 48 60"')
-  expect(svg.endsWith('</svg>')).toBe(true)
-})
+test("renderItemCell returns a self-contained <svg>", () => {
+  const resolved = resolveItem(ITEM_HULL_PLATES);
+  const svg = renderItemCell({ resolved, size: 48 });
+  expect(svg.startsWith("<svg ")).toBe(true);
+  expect(svg).toContain('viewBox="0 0 48 60"');
+  expect(svg.endsWith("</svg>")).toBe(true);
+});
 
-test('component cell renders abbreviation', () => {
-  const resolved = resolveItem(ITEM_HULL_PLATES)
-  const svg = renderItemCell({ resolved, size: 48 })
-  expect(svg).toContain('>HP<')
-})
+test("component cell renders abbreviation", () => {
+  const resolved = resolveItem(ITEM_HULL_PLATES);
+  const svg = renderItemCell({ resolved, size: 48 });
+  expect(svg).toContain(">HP<");
+});
 
-test('module cell renders abbreviation', () => {
-  const resolved = resolveItem(ITEM_ENGINE_T1)
-  const svg = renderItemCell({ resolved, size: 48 })
-  expect(svg).toContain('>EN<')
-})
+test("module cell renders abbreviation", () => {
+  const resolved = resolveItem(ITEM_ENGINE_T1);
+  const svg = renderItemCell({ resolved, size: 48 });
+  expect(svg).toContain(">EN<");
+});
 
-test('entity cell renders abbreviation', () => {
-  const resolved = resolveItem(ITEM_SHIP_T1_PACKED)
-  const svg = renderItemCell({ resolved, size: 48 })
-  expect(svg).toContain('>SH<')
-})
+test("entity cell renders abbreviation", () => {
+  const resolved = resolveItem(ITEM_SHIP_T1_PACKED);
+  const svg = renderItemCell({ resolved, size: 48 });
+  expect(svg).toContain(">SH<");
+});
 
-test('resource cell renders category icon (no abbreviation)', () => {
-  const resolved = resolveItem(101)
-  const svg = renderItemCell({ resolved, size: 48 })
-  expect(svg).not.toMatch(/>[A-Z]{2,3}</)
-  expect(svg).toMatch(/<(polygon|circle|rect)\b/)
-})
+test("resource cell renders category icon (no abbreviation)", () => {
+  const resolved = resolveItem(101);
+  const svg = renderItemCell({ resolved, size: 48 });
+  expect(svg).not.toMatch(/>[A-Z]{2,3}</);
+  expect(svg).toMatch(/<(polygon|circle|rect)\b/);
+});
 
-test('quantity renders as plain bold number when quantity > 1', () => {
-  const resolved = resolveItem(ITEM_HULL_PLATES)
-  const svg = renderItemCell({ resolved, quantity: 42, size: 48 })
-  expect(svg).toContain('>42<')
-  expect(svg).not.toContain('×')
-})
+test("quantity renders as plain bold number when quantity > 1", () => {
+  const resolved = resolveItem(ITEM_HULL_PLATES);
+  const svg = renderItemCell({ resolved, quantity: 42, size: 48 });
+  expect(svg).toContain(">42<");
+  expect(svg).not.toContain("×");
+});
 
-test('no quantity text when quantity is 1 or omitted', () => {
-  const resolved = resolveItem(ITEM_HULL_PLATES)
-  const svgNoQty = renderItemCell({ resolved, size: 48 })
-  const svgOne = renderItemCell({ resolved, quantity: 1, size: 48 })
-  expect(svgNoQty).not.toContain('>1<')
-  expect(svgOne).not.toContain('>1<')
-})
+test("no quantity text when quantity is 1 or omitted", () => {
+  const resolved = resolveItem(ITEM_HULL_PLATES);
+  const svgNoQty = renderItemCell({ resolved, size: 48 });
+  const svgOne = renderItemCell({ resolved, quantity: 1, size: 48 });
+  expect(svgNoQty).not.toContain(">1<");
+  expect(svgOne).not.toContain(">1<");
+});
 
-test('itemCellGroup returns <g> with translate, no <svg> wrapper', () => {
-  const resolved = resolveItem(ITEM_HULL_PLATES)
-  const g = itemCellGroup({ resolved, size: 48, x: 100, y: 200 })
-  expect(g.startsWith('<g ')).toBe(true)
-  expect(g).toContain('transform="translate(100, 200)"')
-  expect(g.startsWith('<svg')).toBe(false)
-})
+test("itemCellGroup returns <g> with translate, no <svg> wrapper", () => {
+  const resolved = resolveItem(ITEM_HULL_PLATES);
+  const g = itemCellGroup({ resolved, size: 48, x: 100, y: 200 });
+  expect(g.startsWith("<g ")).toBe(true);
+  expect(g).toContain('transform="translate(100, 200)"');
+  expect(g.startsWith("<svg")).toBe(false);
+});
 
-test('tier border uses SDK tierColors for the resolved tier', () => {
-  const resolved = resolveItem(ITEM_HULL_PLATES)
-  const svg = renderItemCell({ resolved, size: 48 })
-  expect(svg).toContain('#8b8b8b')
-})
+test("tier border uses SDK tierColors for the resolved tier", () => {
+  const resolved = resolveItem(ITEM_HULL_PLATES);
+  const svg = renderItemCell({ resolved, size: 48 });
+  expect(svg).toContain("#8b8b8b");
+});
 
-test('abbreviation cell uses proportional font size for different sizes', () => {
-  const resolved = resolveItem(ITEM_HULL_PLATES)
-  const svg28 = renderItemCell({ resolved, size: 28 })
-  const svg80 = renderItemCell({ resolved, size: 80 })
-  expect(svg28).toContain('font-size="8"')
-  expect(svg80).toContain('font-size="22"')
-})
+test("abbreviation cell uses proportional font size for different sizes", () => {
+  const resolved = resolveItem(ITEM_HULL_PLATES);
+  const svg28 = renderItemCell({ resolved, size: 28 });
+  const svg80 = renderItemCell({ resolved, size: 80 });
+  expect(svg28).toContain('font-size="8"');
+  expect(svg80).toContain('font-size="22"');
+});
 
-test('resource icon renders in stroke-only mode', () => {
-  const resolved = resolveItem(101)
-  const svg = renderItemCell({ resolved, size: 48 })
-  expect(svg).toContain('fill="none"')
-  expect(svg).toContain('stroke-width="1.5"')
-})
+test("resource icon renders in stroke-only mode", () => {
+  const resolved = resolveItem(101);
+  const svg = renderItemCell({ resolved, size: 48 });
+  expect(svg).toContain('fill="none"');
+  expect(svg).toContain('stroke-width="1.5"');
+});
 
-test('matches golden SVG snapshot per itemType', () => {
+test("matches golden SVG snapshot per itemType", () => {
   const cases: [number, string][] = [
-    [101, 'item-cell-resource'],
-    [ITEM_HULL_PLATES, 'item-cell-component'],
-    [ITEM_ENGINE_T1, 'item-cell-module'],
-    [ITEM_SHIP_T1_PACKED, 'item-cell-entity'],
-  ]
+    [101, "item-cell-resource"],
+    [ITEM_HULL_PLATES, "item-cell-component"],
+    [ITEM_ENGINE_T1, "item-cell-module"],
+    [ITEM_SHIP_T1_PACKED, "item-cell-entity"],
+  ];
   for (const [id, name] of cases) {
-    const svg = renderItemCell({ resolved: resolveItem(id), quantity: 3, size: 48 })
-    expect(svg).toMatchSnapshot(name)
+    const svg = renderItemCell({ resolved: resolveItem(id), quantity: 3, size: 48 });
+    expect(svg).toMatchSnapshot(name);
   }
-})
+});

package/test/templates-module.test.ts

@@ -1,63 +1,63 @@
-import { test, expect } from 'bun:test'
-import { resolveItem } from '@shipload/sdk'
-import { renderModule } from '../src/templates/module.ts'
-import { FIXTURES } from './fixtures/cargo-items.ts'
+import { test, expect } from "bun:test";
+import { resolveItem } from "@shipload/sdk";
+import { renderModule } from "../src/templates/module.ts";
+import { FIXTURES } from "./fixtures/cargo-items.ts";
 
 const CASES = [
-  'engineT1',
-  'generatorT1',
-  'gathererT1',
-  'loaderT1',
-  'crafterT1',
-  'storageT1',
-  'haulerT1',
-] as const
+  "engineT1",
+  "generatorT1",
+  "gathererT1",
+  "loaderT1",
+  "crafterT1",
+  "storageT1",
+  "haulerT1",
+] as const;
 
 for (const name of CASES) {
   test(`matches the committed ${name} snapshot`, async () => {
-    const item = FIXTURES[name]
-    const resolved = resolveItem(item.item_id, item.stats, item.modules)
-    const svg = renderModule(item, resolved)
-    expect(svg).toMatchSnapshot(`module-${name}.svg`)
-  })
+    const item = FIXTURES[name];
+    const resolved = resolveItem(item.item_id, item.stats, item.modules);
+    const svg = renderModule(item, resolved);
+    expect(svg).toMatchSnapshot(`module-${name}.svg`);
+  });
 }
 
-test('Engine template embeds the narrative description', () => {
-  const item = FIXTURES.engineT1
-  const resolved = resolveItem(item.item_id, item.stats, item.modules)
-  const svg = renderModule(item, resolved)
-  expect(svg).toContain('generates')
-  expect(svg).toContain('thrust for travel')
-  expect(svg).toContain('while draining')
-  expect(svg).toContain('distance travelled')
-})
+test("Engine template embeds the narrative description", () => {
+  const item = FIXTURES.engineT1;
+  const resolved = resolveItem(item.item_id, item.stats, item.modules);
+  const svg = renderModule(item, resolved);
+  expect(svg).toContain("generates");
+  expect(svg).toContain("thrust for travel");
+  expect(svg).toContain("while draining");
+  expect(svg).toContain("distance travelled");
+});
 
-test('Hauler template falls back to compact rows when description is null', () => {
-  const item = FIXTURES.haulerT1
-  const resolved = resolveItem(item.item_id, item.stats, item.modules)
-  const svg = renderModule(item, resolved)
-  expect(svg).toContain('Hauler')
-})
+test("Hauler template falls back to compact rows when description is null", () => {
+  const item = FIXTURES.haulerT1;
+  const resolved = resolveItem(item.item_id, item.stats, item.modules);
+  const svg = renderModule(item, resolved);
+  expect(svg).toContain("Hauler");
+});
 
-test('renderModule ranges mode shows capability header without narrative or attribute values', () => {
-  const item = FIXTURES.engineT1
-  const resolved = resolveItem(item.item_id)
-  const svg = renderModule(item, resolved, { mode: 'ranges' })
-  expect(svg).toContain('ENGINE')
-  expect(svg).not.toMatch(/>\d{3,}<\/(text|tspan)>/)
-  expect(svg).toContain('MODULE')
-})
+test("renderModule ranges mode shows capability header without narrative or attribute values", () => {
+  const item = FIXTURES.engineT1;
+  const resolved = resolveItem(item.item_id);
+  const svg = renderModule(item, resolved, { mode: "ranges" });
+  expect(svg).toContain("ENGINE");
+  expect(svg).not.toMatch(/>\d{3,}<\/(text|tspan)>/);
+  expect(svg).toContain("MODULE");
+});
 
-test('renderModule values mode (default) still shows narrative', () => {
-  const item = FIXTURES.engineT1
-  const resolved = resolveItem(item.item_id, item.stats)
-  const svg = renderModule(item, resolved)
-  expect(svg).toMatch(/thrust|energy|generates/)
-})
+test("renderModule values mode (default) still shows narrative", () => {
+  const item = FIXTURES.engineT1;
+  const resolved = resolveItem(item.item_id, item.stats);
+  const svg = renderModule(item, resolved);
+  expect(svg).toMatch(/thrust|energy|generates/);
+});
 
-test('renderModule ranges mode matches snapshot', () => {
-  const item = FIXTURES.engineT1
-  const resolved = resolveItem(item.item_id)
-  const svg = renderModule(item, resolved, { mode: 'ranges' })
-  expect(svg).toMatchSnapshot('module-ranges')
-})
+test("renderModule ranges mode matches snapshot", () => {
+  const item = FIXTURES.engineT1;
+  const resolved = resolveItem(item.item_id);
+  const svg = renderModule(item, resolved, { mode: "ranges" });
+  expect(svg).toMatchSnapshot("module-ranges");
+});