Update

.github/workflows/main.yml

@@ -9,7 +9,7 @@ jobs:
             fail-fast: true
             matrix:
                 os: [ubuntu-latest, windows-latest]
-                php: [8.2, 8.3]
+                php: [8.2, 8.3, 8.4]
                 stability: [prefer-lowest, prefer-stable]
 
         name: P${{ matrix.php }} - ${{ matrix.stability }} - ${{ matrix.os }}

.gitignore

@@ -20,4 +20,5 @@ yarn-error.log
 vendor
 vendor/
 composer.lock
-todo.txt
+todo.txt
+/build/**

.phpstorm.meta.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace PHPSTORM_META {
+
+    // Helper functions for PHP Datatypes
+    override(\int8(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Signed\Int8::class,
+    ]));
+
+    override(\int16(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Signed\Int16::class,
+    ]));
+
+    override(\int32(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Signed\Int32::class,
+    ]));
+
+    override(\int64(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Signed\Int64::class,
+    ]));
+
+    override(\uint8(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Unsigned\UInt8::class,
+    ]));
+
+    override(\uint16(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Unsigned\UInt16::class,
+    ]));
+
+    override(\uint32(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Unsigned\UInt32::class,
+    ]));
+
+    override(\uint64(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Integers\Unsigned\UInt64::class,
+    ]));
+
+    override(\float32(0.0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\FloatingPoints\Float32::class,
+    ]));
+
+    override(\float64(0.0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\FloatingPoints\Float64::class,
+    ]));
+
+    override(\char(''), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Char::class,
+    ]));
+
+    override(\byte(0), map([
+        '' => \Nejcc\PhpDatatypes\Scalar\Byte::class,
+    ]));
+
+    override(\some(0), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Option::class,
+    ]));
+
+    override(\none(), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Option::class,
+    ]));
+
+    override(\option(0), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Option::class,
+    ]));
+
+    override(\ok(0), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Result::class,
+    ]));
+
+    override(\err(0), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Result::class,
+    ]));
+
+    override(\result(function(){}), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Result::class,
+    ]));
+
+    override(\stringArray([]), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Arrays\StringArray::class,
+    ]));
+
+    override(\intArray([]), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Arrays\IntArray::class,
+    ]));
+
+    override(\floatArray([]), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Arrays\FloatArray::class,
+    ]));
+
+    override(\byteSlice([]), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Arrays\ByteSlice::class,
+    ]));
+
+    override(\listData([]), map([
+        '' => \Nejcc\PhpDatatypes\Composite\ListData::class,
+    ]));
+
+    override(\dictionary([]), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Dictionary::class,
+    ]));
+
+    override(\struct([]), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Struct\Struct::class,
+    ]));
+
+    override(\union([], []), map([
+        '' => \Nejcc\PhpDatatypes\Composite\Union\UnionType::class,
+    ]));
+}

CHANGELOG.md

@@ -1,7 +1,77 @@
 # Changelog
 
-All notable changes to `php-datatypes` will be documented in this file
+All notable changes to `php-datatypes` will be documented in this file.
 
-## 1.0.0 - 201X-XX-XX
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-- initial release
+## [2.0.0] - 2024-12-19
+
+### Added
+- PHP 8.4 compatibility and CI testing
+- PHPStan static analysis configuration (level 9)
+- `Dictionary::toArray()`, `isEmpty()`, and `getAll()` methods
+- Benchmark suite for performance testing
+- `Option<T>` type for nullable values
+- `Result<T, E>` type for error handling
+- Mutation testing with Infection
+- Laravel integration (validation rules, service provider)
+- PHPStorm metadata for better IDE support
+- Comprehensive example demonstrating all features
+
+### Changed
+- **BREAKING:** All concrete datatype classes are now `final` to prevent inheritance issues
+- **BREAKING:** All methods now have explicit return types for better type safety
+- **BREAKING:** All Laravel validation rules and casts are now `final`
+- Updated minimum PHP version requirement to ^8.4
+- Enhanced CI workflow to test PHP 8.4
+- Improved code quality with static analysis
+- Enhanced parameter type declarations throughout the codebase
+
+### Fixed
+- Missing serialization methods in Dictionary class
+- Missing return types in various methods
+- Parameter type declarations for better type safety
+
+### Migration Guide
+
+If you were extending any datatype classes, you'll need to use composition instead:
+
+**Before (v1.x):**
+```php
+class MyCustomInt8 extends Int8 {
+    // custom implementation
+}
+```
+
+**After (v2.0):**
+```php
+class MyCustomInt8 {
+    private Int8 $int8;
+
+    public function __construct(int $value) {
+        $this->int8 = new Int8($value);
+    }
+
+    public function getValue(): int {
+        return $this->int8->getValue();
+    }
+
+    // delegate other methods as needed
+}
+```
+
+## [1.0.0] - 2024-12-19
+
+### Added
+- Initial release with comprehensive type system
+- Scalar types: Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UInt128
+- Floating point types: Float32, Float64
+- Boolean, Char, and Byte types
+- Composite types: Arrays, Structs, Unions, Lists, Dictionaries
+- String types: AsciiString, Utf8String, EmailString, and 20+ specialized string types
+- Vector types: Vec2, Vec3, Vec4
+- Serialization support: JSON, XML, Binary
+- Comprehensive test suite (592 tests, 1042 assertions)
+- Helper functions for all types
+- Type-safe operations with overflow/underflow protection