fix(positive-integer): 🐛 Extend PositiveNumber instead of Integer

docs/reference/positive-integer.md

@@ -16,7 +16,7 @@ import { PositiveInteger } from '@haskou/value-objects';
 ## Signature
 
 ```typescript
-class PositiveInteger extends Integer
+class PositiveInteger extends PositiveNumber
 ```
 
 ## Constructor
@@ -52,7 +52,8 @@ items.divide(2); // throws InvalidIntegerError
 
 ## Notes
 
-- Like `PositiveNumber`, it accepts `0`.
+- Like `PositiveNumber`, it accepts `0`. It is not an `Integer` subclass: `instanceof Integer` is `false`.
+- The sign is checked first, so `-0.5` throws `InvalidPositiveNumberError`, not `InvalidIntegerError`.
 - Arithmetic is inherited from `NumberValueObject` and goes through the constructor, so a result that is negative or not an integer throws.
 
 ## Related

src/value-objects/PositiveInteger.ts

@@ -1,16 +1,16 @@
-import { InvalidPositiveNumberError } from '../errors/InvalidPositiveNumberError';
+import { InvalidIntegerError } from '../errors/InvalidIntegerError';
 import { assert } from '../patterns/Assert';
-import { Integer } from './Integer';
 import { NullObject } from './NullObject';
 import { NumberValueObject } from './NumberValueObject';
+import { PositiveNumber } from './PositiveNumber';
 
-export class PositiveInteger extends Integer {
+export class PositiveInteger extends PositiveNumber {
   constructor(value: number | NumberValueObject) {
     super(value?.valueOf());
 
     if (NullObject.isNullObject(this)) {
       return this;
     }
-    assert(this.value >= 0, new InvalidPositiveNumberError());
+    assert(this.value % 1 === 0, new InvalidIntegerError(this.value));
   }
 }

tests/value-objects/PositiveInteger.spec.ts

@@ -5,6 +5,7 @@ import {
   InvalidPositiveNumberError,
   NullObject,
   PositiveInteger,
+  PositiveNumber,
 } from '../../src';
 
 describe('PositiveInteger', () => {
@@ -34,7 +35,9 @@ describe('PositiveInteger', () => {
 
     it('should reject non-integer values', () => {
       expect(() => new PositiveInteger(1.5)).toThrow(InvalidIntegerError);
-      expect(() => new PositiveInteger(-0.5)).toThrow(InvalidIntegerError);
+      expect(() => new PositiveInteger(-0.5)).toThrow(
+        InvalidPositiveNumberError,
+      );
     });
 
     it('should reject NaN and infinite values', () => {
@@ -52,8 +55,12 @@ describe('PositiveInteger', () => {
   });
 
   describe('inheritance', () => {
-    it('should inherit from Integer', () => {
-      expect(new PositiveInteger(1)).toBeInstanceOf(Integer);
+    it('should inherit from PositiveNumber', () => {
+      expect(new PositiveInteger(1)).toBeInstanceOf(PositiveNumber);
+    });
+
+    it('should not inherit from Integer', () => {
+      expect(new PositiveInteger(1)).not.toBeInstanceOf(Integer);
     });
 
     it('should not be equal to an Integer with the same value', () => {