Add FloatPositive type with validation, alias PositiveFloat, and tests

- Introduced `FloatPositive` class to enforce positive float values with strict validation.
- Added `PositiveFloat` alias for enhanced readability and usage clarity.
- Implemented comprehensive test suite to verify valid cases and exception handling on invalid values.
- Updated `psalmTest.php` with usage demonstrations for `PositiveFloat`.

Author: georgedeploy

phpunit.xml

@@ -20,7 +20,7 @@
             <directory>src</directory>
         </include>
         <exclude>
-            <file>src/psalmTest.php</file>
+            <file>src/typeUsageTest.php</file>
         </exclude>
     </source>
 </phpunit>

src/Float/Alias/PositiveFloat.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpTypedValues\Float\Alias;
+
+use PhpTypedValues\Float\FloatPositive;
+
+/**
+ * @psalm-immutable
+ */
+readonly class PositiveFloat extends FloatPositive
+{
+}

src/Float/FloatPositive.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpTypedValues\Float;
+
+use PhpTypedValues\Abstract\Float\FloatType;
+use PhpTypedValues\Exception\FloatTypeException;
+
+use function sprintf;
+
+/**
+ * Positive float (> 0.0).
+ *
+ * Example "0.1"
+ *
+ * @psalm-immutable
+ */
+readonly class FloatPositive extends FloatType
+{
+    protected float $value;
+
+    /**
+     * @throws FloatTypeException
+     */
+    public function __construct(float $value)
+    {
+        if ($value <= 0.0) {
+            throw new FloatTypeException(sprintf('Expected positive float, got "%s"', $value));
+        }
+
+        $this->value = $value;
+    }
+
+    /**
+     * @throws FloatTypeException
+     */
+    public static function fromFloat(float $value): static
+    {
+        return new static($value);
+    }
+
+    /**
+     * @throws FloatTypeException
+     */
+    public static function fromString(string $value): static
+    {
+        parent::assertFloatString($value);
+
+        return new static((float) $value);
+    }
+
+    public function value(): float
+    {
+        return $this->value;
+    }
+}

src/psalmTest.php renamed to src/typeUsageTest.php

@@ -19,6 +19,7 @@
 use PhpTypedValues\Float\Alias\Double;
 use PhpTypedValues\Float\Alias\FloatType;
 use PhpTypedValues\Float\Alias\NonNegativeFloat;
+use PhpTypedValues\Float\Alias\PositiveFloat;
 use PhpTypedValues\Float\FloatNonNegative;
 use PhpTypedValues\Float\FloatStandard;
 use PhpTypedValues\Integer\Alias\Id;
@@ -84,6 +85,7 @@
 echo NonNegativeFloat::fromString('2.71828')->toString() . \PHP_EOL;
 echo FloatType::fromString('2.71828')->toString() . \PHP_EOL;
 echo Double::fromString('2.71828')->toString() . \PHP_EOL;
+echo PositiveFloat::fromString('2.8')->toString() . \PHP_EOL;
 
 // PositiveFloat usage
 testPositiveFloat(FloatNonNegative::fromFloat(0.5)->value());

tests/Unit/Float/FloatPositiveTest.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Exception\FloatTypeException;
+use PhpTypedValues\Float\FloatPositive;
+
+it('constructs positive float via constructor', function (): void {
+    $v = new FloatPositive(0.1);
+    expect($v->value())->toBe(0.1)
+        ->and($v->toString())->toBe('0.1');
+});
+
+it('creates from float factory', function (): void {
+    $v = FloatPositive::fromFloat(1.5);
+    expect($v->value())->toBe(1.5);
+});
+
+it('creates from string factory', function (): void {
+    $v = FloatPositive::fromString('2.5');
+    expect($v->value())->toBe(2.5)
+        ->and($v->toString())->toBe('2.5');
+});
+
+it('throws on zero via constructor', function (): void {
+    expect(fn() => new FloatPositive(0.0))
+        ->toThrow(FloatTypeException::class, 'Expected positive float, got "0"');
+});
+
+it('throws on zero via fromString', function (): void {
+    expect(fn() => FloatPositive::fromString('0.0'))
+        ->toThrow(FloatTypeException::class, 'Expected positive float, got "0"');
+});
+
+it('throws on negative via constructor', function (): void {
+    expect(fn() => new FloatPositive(-0.1))
+        ->toThrow(FloatTypeException::class, 'Expected positive float, got "-0.1"');
+});
+
+it('throws on negative via fromString', function (): void {
+    expect(fn() => FloatPositive::fromString('-1.23'))
+        ->toThrow(FloatTypeException::class, 'Expected positive float, got "-1.23"');
+});
+
+it('throws on string not float', function (): void {
+    expect(fn() => FloatPositive::fromString('unknown'))
+        ->toThrow(FloatTypeException::class, 'String "unknown" has no valid float value');
+});