@novasamatech/scale 0.7.4-0 → 0.7.5-0

package/dist/errEnum.d.ts

@@ -1,11 +1,14 @@
 import type { Codec, CodecType } from 'scale-ts';
 import type { CodecError, ErrCodec } from './err.js';
+type ErrEnumArguments<T> = [value: Codec<T>, message: string | ((value: T) => string)];
 type MapErrEnum<Name extends string, T extends Record<string, ErrEnumArguments<any>>> = {
     [K in keyof T]: ErrCodec<CodecType<T[K][0]>, K extends string ? `${Name}::${K}` : Name>;
 };
 type ErrEnumInput<Name extends string, T extends Record<string, ErrEnumArguments<any>>> = {
     [K in keyof T]: CodecError<CodecType<T[K][0]>, K extends string ? `${Name}::${K}` : Name>;
 }[keyof T];
-type ErrEnumArguments<T> = [value: Codec<T>, message: string | ((value: T) => string)];
-export declare function ErrEnum<const Name extends string, const T extends Record<string, ErrEnumArguments<any>>>(name: Name, inner: T): Codec<ErrEnumInput<Name, T>> & MapErrEnum<Name, T>;
+type ErrEnumCodec<Name extends string, T extends Record<string, ErrEnumArguments<any>>> = Codec<ErrEnumInput<Name, T>> & MapErrEnum<Name, T> & {
+    [Symbol.hasInstance](v: unknown): v is ErrEnumInput<Name, T>;
+};
+export declare function ErrEnum<const Name extends string, const T extends Record<string, ErrEnumArguments<any>>>(name: Name, inner: T): ErrEnumCodec<Name, T>;
 export {};

package/dist/errEnum.js

@@ -2,9 +2,14 @@ import { enhanceCodec } from 'scale-ts';
 import { Enum } from './enum.js';
 import { Err } from './err.js';
 export function ErrEnum(name, inner) {
-    const values = Object.fromEntries(Object.entries(inner).map(([k, [value, message]]) => {
-        return [k, Err(`${name}::${k}`, value, message, k)];
-    }));
-    const codec = enhanceCodec(Enum(values), v => ({ tag: v.instance, value: v }), v => v.value);
-    return Object.assign(codec, values);
+    const variants = Object.fromEntries(Object.entries(inner).map(([k, [value, message]]) => [k, Err(`${name}::${k}`, value, message, k)]));
+    const codec = enhanceCodec(Enum(variants), v => ({ tag: v.instance, value: v }), v => v.value);
+    const result = Object.assign(codec, variants);
+    // defineProperty (not Object.assign) so the symbol stays non-enumerable —
+    // otherwise Object.assign'ing the codec into another target would propagate
+    // the hasInstance hook and silently change that target's instanceof.
+    Object.defineProperty(result, Symbol.hasInstance, {
+        value: (v) => Object.values(variants).some(C => v instanceof C),
+    });
+    return result;
 }

package/dist/errEnum.spec.js

@@ -11,6 +11,30 @@ describe('ErrEnum', () => {
         expect(error.name).toBe('ErrorCodec::TestError');
         expect(error.message).toBe('Test message');
     });
+    it('should support `instanceof` against the enum itself', () => {
+        const A = ErrEnum('A', {
+            First: [_void, 'First'],
+            Second: [_void, 'Second'],
+        });
+        const B = ErrEnum('B', {
+            Other: [_void, 'Other'],
+        });
+        const first = new A.First(undefined);
+        const other = new B.Other(undefined);
+        expect(first instanceof A).toBe(true);
+        expect(first instanceof A.First).toBe(true);
+        expect(first instanceof A.Second).toBe(false);
+        expect(other instanceof A).toBe(false);
+        expect(new Error('plain') instanceof A).toBe(false);
+        const e = first;
+        if (e instanceof A) {
+            expect(e.name).toBe('A::First');
+            expect(e.payload).toBeUndefined();
+        }
+        else {
+            throw new Error('narrowing failed');
+        }
+    });
     it('should correctly serialize/deserialize', () => {
         const ErrorCodec = ErrEnum('ErrorCodec', {
             First: [_void, 'First'],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/scale",
   "type": "module",
-  "version": "0.7.4-0",
+  "version": "0.7.5-0",
   "description": "additional scale-ts bindings",
   "license": "Apache-2.0",
   "repository": {