Add StringNonBlank type with tryFromString and comprehensive tests

- Implemented `StringNonBlank` class to represent non-blank strings (not empty or whitespace-only).
- Added `fromString` and `tryFromString` methods to validate input, returning `Undefined` for invalid cases.
- Updated `Usage` examples to demonstrate `StringNonBlank` behavior.
- Included thorough unit tests to validate creation, exception handling, and `Undefined` behavior for blank inputs.

Author: georgedeploy

.gitignore

@@ -1 +1,2 @@
+.idea
 /vendor/

src/String/StringNonBlank.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpTypedValues\String;
+
+use PhpTypedValues\Abstract\String\StrType;
+use PhpTypedValues\Exception\StringTypeException;
+use PhpTypedValues\Exception\TypeException;
+use PhpTypedValues\Undefined\Alias\Undefined;
+
+use function sprintf;
+use function trim;
+
+/**
+ * Non-blank string value (not empty and not only whitespace).
+ *
+ * Example "hello" or " hi ".
+ *
+ * @psalm-immutable
+ */
+readonly class StringNonBlank extends StrType
+{
+    /** @var non-empty-string */
+    protected string $value;
+
+    /**
+     * @throws StringTypeException
+     */
+    public function __construct(string $value)
+    {
+        if (trim($value) === '') {
+            throw new StringTypeException(sprintf('Expected non-blank string, got "%s"', $value));
+        }
+
+        /** @var non-empty-string $value */
+        $this->value = $value;
+    }
+
+    public static function tryFromString(string $value): static|Undefined
+    {
+        try {
+            return static::fromString($value);
+        } catch (TypeException) {
+            return Undefined::create();
+        }
+    }
+
+    /**
+     * @throws StringTypeException
+     */
+    public static function fromString(string $value): static
+    {
+        return new static($value);
+    }
+
+    /** @return non-empty-string */
+    public function value(): string
+    {
+        return $this->value;
+    }
+}

src/Usage/String.php

@@ -6,10 +6,12 @@
 use PhpTypedValues\String\Alias\StrType;
 use PhpTypedValues\String\Json;
 use PhpTypedValues\String\MariaDb\StringVarChar255;
+use PhpTypedValues\String\StringNonBlank;
 use PhpTypedValues\String\StringNonEmpty;
 use PhpTypedValues\String\StringStandard;
 use PhpTypedValues\String\StringUuidV4;
 use PhpTypedValues\String\StringUuidV7;
+use PhpTypedValues\Undefined\Alias\Undefined;
 
 /**
  * String.
@@ -23,6 +25,12 @@
 echo Str::fromString('hi')->toString() . \PHP_EOL;
 echo StringNonEmpty::tryFromString('hi')->toString() . \PHP_EOL;
 echo StringStandard::tryFromString('hi')->toString() . \PHP_EOL;
+// NonBlank usage (valid and try*)
+echo StringNonBlank::fromString(' hi ')->toString() . \PHP_EOL;
+$nb = StringNonBlank::tryFromString('   ');
+if (!($nb instanceof Undefined)) {
+    echo $nb->toString() . \PHP_EOL;
+}
 echo StringUuidV4::tryFromString('550e8400-e29b-41d4-a716-446655440000')->toString() . \PHP_EOL;
 echo StringUuidV7::tryFromString('01890f2a-5bcd-7def-8abc-1234567890ab')->toString() . \PHP_EOL;
 echo StringVarChar255::tryFromString('hi')->toString() . \PHP_EOL;

tests/Unit/String/StringNonBlank/StringNonBlankTest.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+use PhpTypedValues\Exception\StringTypeException;
+use PhpTypedValues\String\StringNonBlank;
+use PhpTypedValues\Undefined\Alias\Undefined;
+
+it('StringNonBlank accepts non-blank strings and preserves value/toString', function (): void {
+    $v = new StringNonBlank(' hi ');
+
+    expect($v->value())->toBe(' hi ')
+        ->and($v->toString())->toBe(' hi ')
+        ->and((string) $v)->toBe(' hi ');
+});
+
+it('StringNonBlank throws on empty or whitespace-only strings', function (): void {
+    expect(fn() => new StringNonBlank(''))
+        ->toThrow(StringTypeException::class, 'Expected non-blank string, got ""')
+        ->and(fn() => StringNonBlank::fromString("  \t  "))
+        // Do not assert exact whitespace count (tabs vs spaces may render differently across environments)
+        ->toThrow(StringTypeException::class, 'Expected non-blank string, got "');
+});
+
+it('StringNonBlank::tryFromString returns value for non-blank and Undefined for blank', function (): void {
+    $ok = StringNonBlank::tryFromString('x');
+    $bad = StringNonBlank::tryFromString('   ');
+
+    expect($ok)->toBeInstanceOf(StringNonBlank::class)
+        ->and($ok->value())->toBe('x')
+        ->and($bad)->toBeInstanceOf(Undefined::class);
+});
+
+it('StringNonBlank for an empty string', function (): void {
+    expect(StringNonBlank::tryFromString(''))
+        ->toBeInstanceOf(Undefined::class);
+
+    expect(fn() => StringNonBlank::fromString(''))
+        ->toThrow(StringTypeException::class, 'Expected non-blank string, got ""');
+});