Upgrade erreur to v7

package.json

@@ -41,6 +41,7 @@
     "test": "pnpm run lint && vitest run --coverage",
     "test:run": "vitest run",
     "test:watch": "vitest --watch",
+    "test:watch:coverage": "vitest --watch --coverage",
     "typecheck": "tsc",
     "typecheck:watch": "tsc --watch"
   },
@@ -85,12 +86,12 @@
     "root": true
   },
   "dependencies": {
-    "@dldc/erreur": "^6.0.6"
+    "@dldc/erreur": "7.0.0-1"
   },
   "devDependencies": {
     "@types/node": "^20.12.7",
-    "@typescript-eslint/eslint-plugin": "^7.6.0",
-    "@typescript-eslint/parser": "^7.6.0",
+    "@typescript-eslint/eslint-plugin": "^7.7.1",
+    "@typescript-eslint/parser": "^7.7.1",
     "@vitest/coverage-v8": "^1.5.0",
     "auto-changelog": "^2.4.0",
     "eslint": "^8.56.0",

src/erreur.ts

@@ -1,5 +1,4 @@
-import type { TKey } from '@dldc/erreur';
-import { Erreur, Key } from '@dldc/erreur';
+import { createErreurStore } from '@dldc/erreur';
 
 export type TZenjsonErreurData =
   | { kind: 'CustomTypeNotFound'; typeName: string }
@@ -8,32 +7,38 @@ export type TZenjsonErreurData =
   | { kind: 'InvalidSerializedSpecialValue'; value: string }
   | { kind: 'DuplicatedCustomTypeName'; typeName: string };
 
-export const ZenjsonErreurKey: TKey<TZenjsonErreurData, false> = Key.create<TZenjsonErreurData>('ZenjsonErreur');
-
-export const ZenjsonErreur = {
-  CustomTypeNotFound: (typeName: string) => {
-    return Erreur.create(new Error('Unexpected: custom type not found'))
-      .with(ZenjsonErreurKey.Provider({ kind: 'CustomTypeNotFound', typeName }))
-      .withName('ZenjsonErreur');
-  },
-  KeyNotFound: (keyName: string) => {
-    return Erreur.create(new Error(`Key ${keyName} not found`))
-      .with(ZenjsonErreurKey.Provider({ kind: 'KeyNotFound', keyName }))
-      .withName('ZenjsonErreur');
-  },
-  UnexpectedSpecialValue: (value: unknown) => {
-    return Erreur.create(new Error(`Unexpected special number value ${String(value)}`))
-      .with(ZenjsonErreurKey.Provider({ kind: 'UnexpectedSpecialValue', value }))
-      .withName('ZenjsonErreur');
-  },
-  InvalidSerializedSpecialValue: (value: string) => {
-    return Erreur.create(new Error(`Invalid serialized special number: ${value}`))
-      .with(ZenjsonErreurKey.Provider({ kind: 'InvalidSerializedSpecialValue', value }))
-      .withName('ZenjsonErreur');
-  },
-  DuplicatedCustomTypeName: (typeName: string) => {
-    return Erreur.create(new Error(`Invalid custom type list: duplicated type name: "${typeName}"`))
-      .with(ZenjsonErreurKey.Provider({ kind: 'DuplicatedCustomTypeName', typeName }))
-      .withName('ZenjsonErreur');
-  },
-};
+const ZenjsonErreurInternal = createErreurStore<TZenjsonErreurData>();
+
+export const ZenjsonErreur = ZenjsonErreurInternal.asReadonly;
+
+export function throwCustomTypeNotFound(typeName: string): never {
+  return ZenjsonErreurInternal.setAndThrow(`Unexpected: custom type "${typeName}" not found`, {
+    kind: 'CustomTypeNotFound',
+    typeName,
+  });
+}
+
+export function throwKeyNotFound(keyName: string): never {
+  return ZenjsonErreurInternal.setAndThrow(`Key "${keyName}" not found`, { kind: 'KeyNotFound', keyName });
+}
+
+export function throwUnexpectedSpecialValue(value: unknown): never {
+  return ZenjsonErreurInternal.setAndThrow(`Unexpected special number value ${String(value)}`, {
+    kind: 'UnexpectedSpecialValue',
+    value,
+  });
+}
+
+export function throwInvalidSerializedSpecialValue(value: string): never {
+  return ZenjsonErreurInternal.setAndThrow(`Invalid serialized special number: ${value}`, {
+    kind: 'InvalidSerializedSpecialValue',
+    value,
+  });
+}
+
+export function throwDuplicatedCustomTypeName(typeName: string): never {
+  return ZenjsonErreurInternal.setAndThrow(`Invalid custom type list: duplicated type name: "${typeName}"`, {
+    kind: 'DuplicatedCustomTypeName',
+    typeName,
+  });
+}

src/mod.ts

@@ -1,4 +1,4 @@
-export { ZenjsonErreur, ZenjsonErreurKey, type TZenjsonErreurData } from './erreur';
+export { ZenjsonErreur, type TZenjsonErreurData } from './erreur';
 export { createRestore, restore } from './restore';
 export { createSanitize, sanitize } from './sanitize';
 export { createTypedKey, createTypedMap, type ITypedKey, type ITypedMap } from './typedMap';

src/restore.ts

@@ -1,4 +1,4 @@
-import { ZenjsonErreur } from './erreur';
+import { throwCustomTypeNotFound } from './erreur';
 import type { ITypedMap } from './typedMap';
 import { createTypedMap } from './typedMap';
 import type { IRestoreContext, TCustomTypes } from './types';
@@ -28,7 +28,7 @@ function restoreInternal(data: unknown, customTypes: TCustomTypes, state: ITyped
       const [typeName, sanitized] = item;
       const type = customTypes.find((t) => t.name === typeName);
       if (!type) {
-        throw ZenjsonErreur.CustomTypeNotFound(typeName);
+        return throwCustomTypeNotFound(typeName);
       }
       return type.restore(sanitized, restoreCtx);
     }

src/typedMap.ts

@@ -1,4 +1,4 @@
-import { ZenjsonErreur } from './erreur';
+import { throwKeyNotFound } from './erreur';
 
 const TYPED_KEY = Symbol('TYPED_KEY');
 
@@ -53,7 +53,7 @@ export function createTypedMap(): ITypedMap {
   function getOrFail<T>(key: ITypedKey<T>): T {
     const value = get(key);
     if (value === undefined) {
-      throw ZenjsonErreur.KeyNotFound(key.name);
+      return throwKeyNotFound(key.name);
     }
     return value;
   }

src/types.ts

@@ -1,4 +1,8 @@
-import { ZenjsonErreur } from './erreur';
+import {
+  throwDuplicatedCustomTypeName,
+  throwInvalidSerializedSpecialValue,
+  throwUnexpectedSpecialValue,
+} from './erreur';
 import type { ITypedMap } from './typedMap';
 
 export interface ICheckContext {
@@ -63,7 +67,7 @@ export const specialNumberType: ICustomType<number, 'Infinity' | '-Infinity' | '
     if (val === -Infinity) {
       return '-Infinity';
     }
-    throw ZenjsonErreur.UnexpectedSpecialValue(val);
+    return throwUnexpectedSpecialValue(val);
   },
   restore: (str) => {
     if (str === 'NaN') {
@@ -75,7 +79,7 @@ export const specialNumberType: ICustomType<number, 'Infinity' | '-Infinity' | '
     if (str === 'Infinity') {
       return Infinity;
     }
-    throw ZenjsonErreur.InvalidSerializedSpecialValue(str);
+    return throwInvalidSerializedSpecialValue(str);
   },
 };
 
@@ -93,7 +97,7 @@ export function validateTypes(types: TCustomTypes): void {
   const names = new Set();
   types.forEach((type) => {
     if (names.has(type.name)) {
-      throw ZenjsonErreur.DuplicatedCustomTypeName(type.name);
+      return throwDuplicatedCustomTypeName(type.name);
     }
     names.add(type.name);
   });