lazy -> optional

Author: joetannenbaum

src/Inertia.php

@@ -11,6 +11,7 @@
  * @method static void flushShared()
  * @method static void version(\Closure|string|null $version)
  * @method static string getVersion()
+ * @method static \Inertia\OptionalProp optional(callable $callback)
  * @method static \Inertia\LazyProp lazy(callable $callback)
  * @method static \Inertia\DeferProp defer(callable $callback, string $group = 'default')
  * @method static \Inertia\AlwaysProp always(mixed $value)

src/OptionalProp.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Inertia;
+
+use Illuminate\Support\Facades\App;
+
+class OptionalProp
+{
+    protected $callback;
+
+    public function __construct(callable $callback)
+    {
+        $this->callback = $callback;
+    }
+
+    public function __invoke()
+    {
+        return App::call($this->callback);
+    }
+}

src/Response.php

@@ -114,7 +114,7 @@ public function resolveProperties(Request $request, array $props): array
 
         if (! $isPartial) {
             $props = array_filter($this->props, static function ($prop) {
-                return ! ($prop instanceof LazyProp) && ! ($prop instanceof DeferProp);
+                return ! ($prop instanceof OptionalProp) && ! ($prop instanceof LazyProp) && ! ($prop instanceof DeferProp);
             });
         }
 
@@ -228,7 +228,7 @@ public function resolvePropertyInstances(array $props, Request $request): array
                 $value = App::call($value);
             }
 
-            if ($value instanceof LazyProp) {
+            if ($value instanceof LazyProp || $value instanceof OptionalProp || $value instanceof DeferProp) {
                 $value = App::call($value);
             }
 

src/ResponseFactory.php

@@ -82,11 +82,19 @@ public function getVersion(): string
         return (string) $version;
     }
 
+    /**
+     * @deprecated Use `optional` instead.
+     */
     public function lazy(callable $callback): LazyProp
     {
         return new LazyProp($callback);
     }
 
+    public function optional(callable $callback): OptionalProp
+    {
+        return new OptionalProp($callback);
+    }
+
     public function defer(callable $callback, string $group = 'default'): DeferProp
     {
         return new DeferProp($callback, $group);

tests/OptionalPropTest.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Inertia\Tests;
+
+use Illuminate\Http\Request;
+use Inertia\OptionalProp;
+
+class OptionalPropTest extends TestCase
+{
+    public function test_can_invoke(): void
+    {
+        $optionalProp = new OptionalProp(function () {
+            return 'A lazy value';
+        });
+
+        $this->assertSame('A lazy value', $optionalProp());
+    }
+
+    public function test_can_resolve_bindings_when_invoked(): void
+    {
+        $optionalProp = new OptionalProp(function (Request $request) {
+            return $request;
+        });
+
+        $this->assertInstanceOf(Request::class, $optionalProp());
+    }
+}

tests/ResponseFactoryTest.php

@@ -12,8 +12,10 @@
 use Illuminate\Support\Facades\Request;
 use Illuminate\Support\Facades\Route;
 use Inertia\AlwaysProp;
+use Inertia\DeferProp;
 use Inertia\Inertia;
 use Inertia\LazyProp;
+use Inertia\OptionalProp;
 use Inertia\ResponseFactory;
 use Inertia\Tests\Stubs\ExampleMiddleware;
 
@@ -161,6 +163,26 @@ public function test_can_create_lazy_prop(): void
         $this->assertInstanceOf(LazyProp::class, $lazyProp);
     }
 
+    public function test_can_create_deferred_prop(): void
+    {
+        $factory = new ResponseFactory();
+        $deferredProp = $factory->defer(function () {
+            return 'A deferred value';
+        });
+
+        $this->assertInstanceOf(DeferProp::class, $deferredProp);
+    }
+
+    public function test_can_create_optional_prop(): void
+    {
+        $factory = new ResponseFactory();
+        $optionalProp = $factory->optional(function () {
+            return 'An optional value';
+        });
+
+        $this->assertInstanceOf(OptionalProp::class, $optionalProp);
+    }
+
     public function test_can_create_always_prop(): void
     {
         $factory = new ResponseFactory();