chore: bump typescript from 6.0.3 to 7.0.2 (#388)

Bumps [typescript](https://github.com/microsoft/TypeScript) from 6.0.3 to 7.0.2.
- [Release notes](https://github.com/microsoft/TypeScript/releases)
- [Commits](https://github.com/microsoft/TypeScript/commits)

---
updated-dependencies:
- dependency-name: typescript
  dependency-version: 7.0.2
  dependency-type: direct:development
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Author: dependabot[bot]

package-lock.json

@@ -6,33 +6,28 @@
     "name": "the native web GmbH",
     "email": "hello@thenativeweb.io"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
-  "types": "./dist/index.d.cts",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
   "dependencies": {
     "testcontainers": "12.0.4"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.3",
     "@types/node": "26.1.1",
     "get-port": "7.2.0",
-    "tsdown": "0.22.4",
     "tsx": "4.23.0",
-    "typescript": "6.0.3"
+    "typescript": "7.0.2"
   },
   "scripts": {
     "analyze": "npx tsc --noEmit && npx biome check --error-on-warnings .",
-    "build": "npx tsc --noEmit && npx tsdown --format cjs,esm --dts --minify --out-dir ./dist ./src/index.ts",
+    "build": "npx tsc -p tsconfig.build.json",
     "format": "npx biome check --write .",
     "qa": "npm run analyze && npm run test",
     "test": "node --test --import tsx \"./src/**/*.test.ts\""

package.json

@@ -36,6 +36,7 @@ suite('Event', { timeout: 30_000 }, () => {
 			assert.equal(writtenEvents.length, 1);
 
 			const writtenEvent = writtenEvents[0];
+			assert.ok(writtenEvent);
 
 			assert.doesNotThrow((): void => {
 				writtenEvent.verifyHash();
@@ -59,6 +60,7 @@ suite('Event', { timeout: 30_000 }, () => {
 			assert.equal(writtenEvents.length, 1);
 
 			const writtenEvent = writtenEvents[0];
+			assert.ok(writtenEvent);
 
 			const invalidHash = crypto.createHash('sha256').update('invalid hash').digest('hex');
 			writtenEvent.hash = invalidHash;
@@ -87,6 +89,7 @@ suite('Event', { timeout: 30_000 }, () => {
 			assert.equal(writtenEvents.length, 1);
 
 			const writtenEvent = writtenEvents[0];
+			assert.ok(writtenEvent);
 			assert.equal(writtenEvent.signature, null);
 
 			const { publicKey: verificationKey } = crypto.generateKeyPairSync('ed25519');
@@ -118,6 +121,7 @@ suite('Event', { timeout: 30_000 }, () => {
 			assert.equal(writtenEvents.length, 1);
 
 			const writtenEvent = writtenEvents[0];
+			assert.ok(writtenEvent);
 			assert.notEqual(writtenEvent.signature, null);
 
 			const invalidHash = crypto.createHash('sha256').update('invalid hash').digest('hex');
@@ -152,6 +156,7 @@ suite('Event', { timeout: 30_000 }, () => {
 			assert.equal(writtenEvents.length, 1);
 
 			const writtenEvent = writtenEvents[0];
+			assert.ok(writtenEvent);
 			assert.notEqual(writtenEvent.signature, null);
 
 			writtenEvent.signature += '0123456789abcdef';
@@ -185,6 +190,7 @@ suite('Event', { timeout: 30_000 }, () => {
 			assert.equal(writtenEvents.length, 1);
 
 			const writtenEvent = writtenEvents[0];
+			assert.ok(writtenEvent);
 			assert.notEqual(writtenEvent.signature, null);
 
 			const verificationKey = container.getVerificationKey();

src/Event.test.ts

@@ -8,12 +8,13 @@ const getImageVersionFromDockerfile = (): string => {
 	const data = fs.readFileSync(dockerfile, 'utf-8');
 
 	const matches = data.match(versionRegex);
+	const version = matches?.[1];
 
-	if (!matches) {
+	if (version === undefined) {
 		throw new Error('Failed to find image version in Dockerfile.');
 	}
 
-	return matches[1];
+	return version;
 };
 
 export { getImageVersionFromDockerfile };

src/getImageVersionFromDockerfile.ts

@@ -168,7 +168,9 @@ suite('observeEvents', { timeout: 30_000 }, () => {
 		}
 
 		assert.equal(eventsObserved.length, 1);
-		assert.equal(eventsObserved[0].data.value, 42);
+		const [eventObserved] = eventsObserved;
+		assert.ok(eventObserved);
+		assert.equal(eventObserved.data.value, 42);
 	});
 
 	test('observes from latest event.', async (): Promise<void> => {
@@ -217,6 +219,8 @@ suite('observeEvents', { timeout: 30_000 }, () => {
 		}
 
 		assert.equal(eventsObserved.length, 1);
-		assert.equal(eventsObserved[0].data.value, 42);
+		const [eventObserved] = eventsObserved;
+		assert.ok(eventObserved);
+		assert.equal(eventObserved.data.value, 42);
 	});
 });

src/observeEvents.test.ts

@@ -129,8 +129,11 @@ suite('readEvents', { timeout: 30_000 }, () => {
 		}
 
 		assert.equal(eventsRead.length, 2);
-		assert.equal(eventsRead[0].data.value, 23);
-		assert.equal(eventsRead[1].data.value, 42);
+		const [firstEventRead, secondEventRead] = eventsRead;
+		assert.ok(firstEventRead);
+		assert.ok(secondEventRead);
+		assert.equal(firstEventRead.data.value, 23);
+		assert.equal(secondEventRead.data.value, 42);
 	});
 
 	test('reads anti-chronologically.', async (): Promise<void> => {
@@ -165,8 +168,11 @@ suite('readEvents', { timeout: 30_000 }, () => {
 		}
 
 		assert.equal(eventsRead.length, 2);
-		assert.equal(eventsRead[0].data.value, 42);
-		assert.equal(eventsRead[1].data.value, 23);
+		const [firstEventRead, secondEventRead] = eventsRead;
+		assert.ok(firstEventRead);
+		assert.ok(secondEventRead);
+		assert.equal(firstEventRead.data.value, 42);
+		assert.equal(secondEventRead.data.value, 23);
 	});
 
 	test('reads with lower bound.', async (): Promise<void> => {
@@ -201,7 +207,9 @@ suite('readEvents', { timeout: 30_000 }, () => {
 		}
 
 		assert.equal(eventsRead.length, 1);
-		assert.equal(eventsRead[0].data.value, 42);
+		const [eventRead] = eventsRead;
+		assert.ok(eventRead);
+		assert.equal(eventRead.data.value, 42);
 	});
 
 	test('reads with upper bound.', async (): Promise<void> => {
@@ -236,7 +244,9 @@ suite('readEvents', { timeout: 30_000 }, () => {
 		}
 
 		assert.equal(eventsRead.length, 1);
-		assert.equal(eventsRead[0].data.value, 23);
+		const [eventRead] = eventsRead;
+		assert.ok(eventRead);
+		assert.equal(eventRead.data.value, 23);
 	});
 
 	test('reads from latest event.', async (): Promise<void> => {
@@ -275,6 +285,8 @@ suite('readEvents', { timeout: 30_000 }, () => {
 		}
 
 		assert.equal(eventsRead.length, 1);
-		assert.equal(eventsRead[0].data.value, 42);
+		const [eventRead] = eventsRead;
+		assert.ok(eventRead);
+		assert.equal(eventRead.data.value, 42);
 	});
 });

src/readEvents.test.ts

@@ -36,7 +36,9 @@ suite('writeEvents', { timeout: 30_000 }, () => {
 		const writtenEvents = await client.writeEvents([event]);
 
 		assert.equal(writtenEvents.length, 1);
-		assert.equal(writtenEvents[0].id, '0');
+		const [writtenEvent] = writtenEvents;
+		assert.ok(writtenEvent);
+		assert.equal(writtenEvent.id, '0');
 	});
 
 	test('writes multiple events.', async (): Promise<void> => {
@@ -63,11 +65,15 @@ suite('writeEvents', { timeout: 30_000 }, () => {
 		const writtenEvents = await client.writeEvents([firstEvent, secondEvent]);
 		assert.equal(writtenEvents.length, 2);
 
-		assert.equal(writtenEvents[0].id, '0');
-		assert.equal(writtenEvents[0].data.value, 23);
+		const [firstWrittenEvent, secondWrittenEvent] = writtenEvents;
+		assert.ok(firstWrittenEvent);
+		assert.ok(secondWrittenEvent);
 
-		assert.equal(writtenEvents[1].id, '1');
-		assert.equal(writtenEvents[1].data.value, 42);
+		assert.equal(firstWrittenEvent.id, '0');
+		assert.equal(firstWrittenEvent.data.value, 23);
+
+		assert.equal(secondWrittenEvent.id, '1');
+		assert.equal(secondWrittenEvent.data.value, 42);
 	});
 
 	test('supports the isSubjectPristine precondition.', async (): Promise<void> => {
@@ -148,8 +154,10 @@ suite('writeEvents', { timeout: 30_000 }, () => {
 		const writtenEvents = await client.writeEvents([secondEvent], [isSubjectPopulated('/test')]);
 
 		assert.equal(writtenEvents.length, 1);
-		assert.equal(writtenEvents[0].id, '1');
-		assert.equal(writtenEvents[0].data.value, 42);
+		const [writtenEvent] = writtenEvents;
+		assert.ok(writtenEvent);
+		assert.equal(writtenEvent.id, '1');
+		assert.equal(writtenEvent.data.value, 42);
 	});
 
 	test('supports the isSubjectOnEventId precondition.', async (): Promise<void> => {

src/writeEvents.test.ts

@@ -0,0 +1,4 @@
+{
+	"extends": "./tsconfig.json",
+	"exclude": ["./src/**/*.test.ts"]
+}

tsconfig.build.json

@@ -1,15 +1,17 @@
 {
 	"compilerOptions": {
-		"declaration": true,
-		"esModuleInterop": true,
-		"lib": ["ES2023"],
-		"module": "esnext",
-		"moduleResolution": "bundler",
+		"module": "nodenext",
+		"target": "esnext",
+		"lib": ["esnext"],
+		"types": ["node"],
+		"noUncheckedIndexedAccess": true,
+		"noImplicitOverride": true,
+		"verbatimModuleSyntax": true,
+		"isolatedModules": true,
+		"erasableSyntaxOnly": true,
 		"outDir": "dist",
-		"resolveJsonModule": true,
-		"strict": true,
-		"target": "ES2023"
+		"rootDir": "./src",
+		"declaration": true
 	},
-	"include": ["./src/**/*.ts"],
-	"exclude": ["./dist"]
+	"include": ["./src/**/*.ts"]
 }