From 71502de178d63d8c5056c7d372dfc548243c3ba9 Mon Sep 17 00:00:00 2001
From: Alex McCabe <alexwmccabe@gmail.com>
Date: Mon, 18 Dec 2023 11:32:26 +0000
Subject: [PATCH 01/17] Improve generated types to include optional types

---
 src/Output/Types.php                     |  8 +++++++-
 src/js/index.d.ts                        | 21 ++++++++++++++++++---
 tests/Unit/CommandRouteGeneratorTest.php |  6 ++++--
 tests/fixtures/ziggy-7.d.ts              |  6 ++++--
 tests/fixtures/ziggy.d.ts                |  7 ++++++-
 5 files changed, 39 insertions(+), 9 deletions(-)

diff --git a/src/Output/Types.php b/src/Output/Types.php
index 45ba303c..d8900e7e 100644
--- a/src/Output/Types.php
+++ b/src/Output/Types.php
@@ -3,6 +3,7 @@
 namespace Tightenco\Ziggy\Output;
 
 use Illuminate\Support\Arr;
+use Str;
 use Stringable;
 use Tightenco\Ziggy\Ziggy;
 
@@ -15,13 +16,18 @@ public function __construct(Ziggy $ziggy)
         $this->ziggy = $ziggy;
     }
 
+    private function isParamOptional(string $uri, string $param): bool
+    {
+        return Str::contains($uri, "{$param}?");
+    }
+
     public function __toString(): string
     {
         $routes = collect($this->ziggy->toArray()['routes'])->map(function ($route) {
             return collect($route['parameters'] ?? [])->map(function ($param) use ($route) {
                 return Arr::has($route, "bindings.{$param}")
                     ? ['name' => $param, 'binding' => $route['bindings'][$param]]
-                    : ['name' => $param];
+                    : ['name' => $param, 'optional' => $this->isParamOptional($route['uri'], $param)];
             });
         });
 
diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index 95c49457..78e2420a 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -61,12 +61,27 @@ type HasQueryParam = { _query?: Record<string, unknown> };
  */
 type GenericRouteParamsObject = Record<keyof any, unknown> & HasQueryParam;
 // `keyof any` essentially makes it function as a plain `Record`
+
+/**
+ * Get only params for `optional: true` or `optional: false`.
+ */
+type GetParamsForOptionalSwitch<I extends readonly ParameterInfo[], TOptional extends boolean> = Extract<
+    I[number],
+    { optional: TOptional }
+>;
+
+/**
+ * Map our parameter info to a routable object. We call twice to handle optional and non-optional params.
+ */
+type MapParamsToRoutable<I extends readonly ParameterInfo[]> =
+    { [T in GetParamsForOptionalSwitch<I, true> as T['name']]?: Routable<T> } &
+    { [T in GetParamsForOptionalSwitch<I, false> as T['name']]: Routable<T> }
+
 /**
  * An object of parameters for a specific named route.
  */
-// TODO: The keys here could be non-optional (or more detailed) if we can determine which params are required/not.
-type KnownRouteParamsObject<I extends readonly ParameterInfo[]> = {
-    [T in I[number] as T['name']]?: Routable<T>;
+type KnownRouteParamsObject<I extends readonly ParameterInfo[], MappedParams = MapParamsToRoutable<I>> = {
+    [K in keyof MappedParams]: MappedParams[K]
 } & GenericRouteParamsObject;
 // `readonly` allows TypeScript to determine the actual values of all the
 // parameter names inside the array, instead of just seeing `string`.
diff --git a/tests/Unit/CommandRouteGeneratorTest.php b/tests/Unit/CommandRouteGeneratorTest.php
index 1cd3fded..ea1ff9b5 100644
--- a/tests/Unit/CommandRouteGeneratorTest.php
+++ b/tests/Unit/CommandRouteGeneratorTest.php
@@ -147,6 +147,7 @@ public function can_generate_dts_file()
     {
         app('router')->get('posts', $this->noop())->name('posts.index');
         app('router')->post('posts/{post}/comments', PostCommentController::class)->name('postComments.store');
+        app('router')->post('posts/{post}/comments{postId?}', PostCommentController::class)->name('postComments.store');
         app('router')->getRoutes()->refreshNameLookups();
 
         Artisan::call('ziggy:generate',  ['--types' => true]);
@@ -165,7 +166,7 @@ public function can_generate_dts_file()
     /** @test */
     public function can_generate_dts_file_with_scoped_bindings()
     {
-        if (! $this->laravelVersion(7)) {
+        if (!$this->laravelVersion(7)) {
             $this->markTestSkipped('Requires Laravel >=7');
         }
 
@@ -275,7 +276,8 @@ public function __toString(): string
 
 class PostCommentController
 {
-    public function __invoke($post, $comment) {
+    public function __invoke($post, $comment)
+    {
         //
     }
 }
diff --git a/tests/fixtures/ziggy-7.d.ts b/tests/fixtures/ziggy-7.d.ts
index c71ee83b..44a29985 100644
--- a/tests/fixtures/ziggy-7.d.ts
+++ b/tests/fixtures/ziggy-7.d.ts
@@ -4,7 +4,8 @@ declare module 'ziggy-js' {
     "posts.index": [],
     "postComments.show": [
         {
-            "name": "post"
+            "name": "post",
+            "optional": false
         },
         {
             "name": "comment",
@@ -13,7 +14,8 @@ declare module 'ziggy-js' {
     ],
     "postComments.store": [
         {
-            "name": "post"
+            "name": "post",
+            "optional": false
         }
     ]
 }
diff --git a/tests/fixtures/ziggy.d.ts b/tests/fixtures/ziggy.d.ts
index 90ea8c89..7705443a 100644
--- a/tests/fixtures/ziggy.d.ts
+++ b/tests/fixtures/ziggy.d.ts
@@ -4,7 +4,12 @@ declare module 'ziggy-js' {
     "posts.index": [],
     "postComments.store": [
         {
-            "name": "post"
+            "name": "post",
+            "optional": false
+        },
+        {
+            "name": "postId",
+            "optional": true
         }
     ]
 }

From e4398f768f6ade5141f1d038a74cab795705cd22 Mon Sep 17 00:00:00 2001
From: Alex McCabe <alexwmccabe@gmail.com>
Date: Mon, 18 Dec 2023 11:39:18 +0000
Subject: [PATCH 02/17] Remove unknown Str class use

---
 src/Output/Types.php | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/Output/Types.php b/src/Output/Types.php
index d8900e7e..1d38b060 100644
--- a/src/Output/Types.php
+++ b/src/Output/Types.php
@@ -3,7 +3,6 @@
 namespace Tightenco\Ziggy\Output;
 
 use Illuminate\Support\Arr;
-use Str;
 use Stringable;
 use Tightenco\Ziggy\Ziggy;
 
@@ -18,7 +17,7 @@ public function __construct(Ziggy $ziggy)
 
     private function isParamOptional(string $uri, string $param): bool
     {
-        return Str::contains($uri, "{$param}?");
+        return str_contains($uri, "{$param}?");
     }
 
     public function __toString(): string

From 98ec2ad61b164d64d8646620c70fff1b3c4e0775 Mon Sep 17 00:00:00 2001
From: Alex McCabe <alexwmccabe@gmail.com>
Date: Tue, 19 Dec 2023 16:10:57 +0000
Subject: [PATCH 03/17] Fix broken TS tests

---
 tests/js/route.test-d.ts | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/tests/js/route.test-d.ts b/tests/js/route.test-d.ts
index 66c03d4d..ce2817a6 100644
--- a/tests/js/route.test-d.ts
+++ b/tests/js/route.test-d.ts
@@ -1,24 +1,29 @@
 import { assertType } from 'vitest';
-import route from '../../src/js';
+import route, { RouteParams } from '../../src/js';
 
 // Add generated routes to use for testing inside this file. In a real app these declarations
 // would be in a separate file generated by running `php artisan ziggy:generate --types`.
 declare module '../../src/js' {
     interface RouteList {
         'posts.index': [];
-        'posts.comments.store': [{ name: 'x' }];
-        'posts.comments.show': [{ name: 'post' }, { name: 'comment'; binding: 'uuid' }];
+        'posts.comments.store': [{ name: 'post'; optional: false }];
+        'posts.comments.show': [
+            { name: 'post'; optional: false },
+            { name: 'comment'; optional: true; binding: 'uuid' },
+        ];
         optional: [{ name: 'maybe' }];
     }
 }
 
+type T = RouteParams<'posts.comments.show'>;
+
 // Test route name autocompletion
-assertType(route());
+assertType(route('posts.comments.show'));
 
 // Test route parameter name autocompletion
-assertType(route('posts.comments.store', {}));
+assertType(route('posts.comments.store', { post: '1' }));
 
-// TODO once we can detect whether params are required/optional: @ts-expect-error missing required 'post' parameter
+// @ts-expect-error missing 'post' key in post parameter object
 assertType(route('posts.comments.show', { comment: 2 }));
 
 // TODO once we can detect whether params are required/optional: @ts-expect-error missing required 'comment' parameter
@@ -39,9 +44,9 @@ assertType(route('posts.comments.show', { post: { id: 2, foo: 'bar' } }));
 assertType(route('posts.comments.show', { post: { foo: 'bar' } }));
 
 // Binding/'routable' object example with custom 'uuid' binding
-assertType(route('posts.comments.show', { comment: { uuid: 1 } }));
+assertType(route('posts.comments.show', { comment: { uuid: 1 }, post: '1' }));
 // Allows extra nested object properties
-assertType(route('posts.comments.show', { comment: { uuid: 1, foo: 'bar' } }));
+assertType(route('posts.comments.show', { comment: { uuid: 1, foo: 'bar' }, post: '1' }));
 // @ts-expect-error missing 'uuid' key in comment parameter object
 assertType(route('posts.comments.show', { comment: { foo: 'bar' } }));
 // @ts-expect-error missing 'uuid' key in comment parameter object

From 110895a2c7cca84a621a966c153fda6c3392217c Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Fri, 22 Dec 2023 14:22:43 -0500
Subject: [PATCH 04/17] Inline optional check and make it work on PHP 7

---
 src/Output/Types.php | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/Output/Types.php b/src/Output/Types.php
index 1d38b060..b90a1480 100644
--- a/src/Output/Types.php
+++ b/src/Output/Types.php
@@ -15,18 +15,13 @@ public function __construct(Ziggy $ziggy)
         $this->ziggy = $ziggy;
     }
 
-    private function isParamOptional(string $uri, string $param): bool
-    {
-        return str_contains($uri, "{$param}?");
-    }
-
     public function __toString(): string
     {
         $routes = collect($this->ziggy->toArray()['routes'])->map(function ($route) {
             return collect($route['parameters'] ?? [])->map(function ($param) use ($route) {
                 return Arr::has($route, "bindings.{$param}")
                     ? ['name' => $param, 'binding' => $route['bindings'][$param]]
-                    : ['name' => $param, 'optional' => $this->isParamOptional($route['uri'], $param)];
+                    : ['name' => $param, 'optional' => strpos($route['uri'], "{$param}?") !== false];
             });
         });
 

From 473782bd210bbcd2264a07156d516d079cdce905 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Fri, 22 Dec 2023 14:29:11 -0500
Subject: [PATCH 05/17] Add optional flag to params with bindings and fix
 invalid test routes

---
 src/Output/Types.php                     | 2 +-
 tests/Unit/CommandRouteGeneratorTest.php | 4 ++--
 tests/fixtures/ziggy-7.d.ts              | 1 +
 tests/fixtures/ziggy.d.ts                | 8 +++++++-
 4 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/Output/Types.php b/src/Output/Types.php
index b90a1480..2c720403 100644
--- a/src/Output/Types.php
+++ b/src/Output/Types.php
@@ -20,7 +20,7 @@ public function __toString(): string
         $routes = collect($this->ziggy->toArray()['routes'])->map(function ($route) {
             return collect($route['parameters'] ?? [])->map(function ($param) use ($route) {
                 return Arr::has($route, "bindings.{$param}")
-                    ? ['name' => $param, 'binding' => $route['bindings'][$param]]
+                    ? ['name' => $param, 'optional' => strpos($route['uri'], "{$param}?") !== false, 'binding' => $route['bindings'][$param]]
                     : ['name' => $param, 'optional' => strpos($route['uri'], "{$param}?") !== false];
             });
         });
diff --git a/tests/Unit/CommandRouteGeneratorTest.php b/tests/Unit/CommandRouteGeneratorTest.php
index ea1ff9b5..02eef33a 100644
--- a/tests/Unit/CommandRouteGeneratorTest.php
+++ b/tests/Unit/CommandRouteGeneratorTest.php
@@ -147,7 +147,7 @@ public function can_generate_dts_file()
     {
         app('router')->get('posts', $this->noop())->name('posts.index');
         app('router')->post('posts/{post}/comments', PostCommentController::class)->name('postComments.store');
-        app('router')->post('posts/{post}/comments{postId?}', PostCommentController::class)->name('postComments.store');
+        app('router')->post('posts/{post}/comments/{comment?}', PostCommentController::class)->name('postComments.storeComment');
         app('router')->getRoutes()->refreshNameLookups();
 
         Artisan::call('ziggy:generate',  ['--types' => true]);
@@ -166,7 +166,7 @@ public function can_generate_dts_file()
     /** @test */
     public function can_generate_dts_file_with_scoped_bindings()
     {
-        if (!$this->laravelVersion(7)) {
+        if (! $this->laravelVersion(7)) {
             $this->markTestSkipped('Requires Laravel >=7');
         }
 
diff --git a/tests/fixtures/ziggy-7.d.ts b/tests/fixtures/ziggy-7.d.ts
index 44a29985..544aaac3 100644
--- a/tests/fixtures/ziggy-7.d.ts
+++ b/tests/fixtures/ziggy-7.d.ts
@@ -9,6 +9,7 @@ declare module 'ziggy-js' {
         },
         {
             "name": "comment",
+            "optional": false,
             "binding": "uuid"
         }
     ],
diff --git a/tests/fixtures/ziggy.d.ts b/tests/fixtures/ziggy.d.ts
index 7705443a..e98fb13f 100644
--- a/tests/fixtures/ziggy.d.ts
+++ b/tests/fixtures/ziggy.d.ts
@@ -3,12 +3,18 @@ declare module 'ziggy-js' {
   interface RouteList {
     "posts.index": [],
     "postComments.store": [
+        {
+            "name": "post",
+            "optional": false
+        }
+    ],
+    "postComments.storeComment": [
         {
             "name": "post",
             "optional": false
         },
         {
-            "name": "postId",
+            "name": "comment",
             "optional": true
         }
     ]

From adfeac8f58a19f4544ba8f118a924a1d07d10fb7 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Fri, 22 Dec 2023 14:40:00 -0500
Subject: [PATCH 06/17] Fix type testing file

---
 tests/js/route.test-d.ts | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/tests/js/route.test-d.ts b/tests/js/route.test-d.ts
index ce2817a6..425d169c 100644
--- a/tests/js/route.test-d.ts
+++ b/tests/js/route.test-d.ts
@@ -11,24 +11,21 @@ declare module '../../src/js' {
             { name: 'post'; optional: false },
             { name: 'comment'; optional: true; binding: 'uuid' },
         ];
-        optional: [{ name: 'maybe' }];
+        optional: [{ name: 'maybe'; optional: true }];
     }
 }
 
 type T = RouteParams<'posts.comments.show'>;
 
-// Test route name autocompletion
-assertType(route('posts.comments.show'));
+// Test route name autocompletion by adding quotes inside `route()` - should suggest route names above
+assertType(route());
 
-// Test route parameter name autocompletion
-assertType(route('posts.comments.store', { post: '1' }));
+// Test route parameter name autocompletion by adding more keys to the parameter object - should show info about params, e.g. for the 'comment' param if you type `c`
+assertType(route('posts.comments.show', { post: 1 }));
 
-// @ts-expect-error missing 'post' key in post parameter object
+// @ts-expect-error missing required 'post' parameter
 assertType(route('posts.comments.show', { comment: 2 }));
 
-// TODO once we can detect whether params are required/optional: @ts-expect-error missing required 'comment' parameter
-assertType(route('posts.comments.show', { post: 2 }));
-
 // Simple object example
 assertType(route('posts.comments.show', { post: 2, comment: 9 }));
 // Allows extra object properties

From 36cdd32b760424ac5775ba086b3fe5258c46f2f8 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Fri, 22 Dec 2023 15:36:24 -0500
Subject: [PATCH 07/17] Refactor type mapping

---
 src/js/index.d.ts        | 30 ++++++++++++------------------
 tests/js/route.test-d.ts |  4 +---
 2 files changed, 13 insertions(+), 21 deletions(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index 78e2420a..b45ea5f6 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -21,7 +21,7 @@ type RouteName = KnownRouteName | (string & {});
 /**
  * Information about a single route parameter.
  */
-type ParameterInfo = { name: string; binding?: string };
+type ParameterInfo = { name: string; optional: boolean; binding?: string };
 
 /**
  * A primitive route parameter value, as it would appear in a URL.
@@ -62,30 +62,24 @@ type HasQueryParam = { _query?: Record<string, unknown> };
 type GenericRouteParamsObject = Record<keyof any, unknown> & HasQueryParam;
 // `keyof any` essentially makes it function as a plain `Record`
 
-/**
- * Get only params for `optional: true` or `optional: false`.
- */
-type GetParamsForOptionalSwitch<I extends readonly ParameterInfo[], TOptional extends boolean> = Extract<
-    I[number],
-    { optional: TOptional }
->;
-
-/**
- * Map our parameter info to a routable object. We call twice to handle optional and non-optional params.
- */
-type MapParamsToRoutable<I extends readonly ParameterInfo[]> =
-    { [T in GetParamsForOptionalSwitch<I, true> as T['name']]?: Routable<T> } &
-    { [T in GetParamsForOptionalSwitch<I, false> as T['name']]: Routable<T> }
-
 /**
  * An object of parameters for a specific named route.
  */
-type KnownRouteParamsObject<I extends readonly ParameterInfo[], MappedParams = MapParamsToRoutable<I>> = {
-    [K in keyof MappedParams]: MappedParams[K]
+type KnownRouteParamsObject<I extends readonly ParameterInfo[]> = {
+    [T in Extract<I[number], { optional: false }> as T['name']]: Routable<T>;
+} & {
+    [T in Extract<I[number], { optional: true }> as T['name']]?: Routable<T>;
 } & GenericRouteParamsObject;
 // `readonly` allows TypeScript to determine the actual values of all the
 // parameter names inside the array, instead of just seeing `string`.
 // See https://github.com/tighten/ziggy/pull/664#discussion_r1329978447.
+
+// Uncomment to test:
+// type A = KnownRouteParamsObject<
+//     [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }]
+// >;
+// = { foo: ..., bar?: ... }
+
 /**
  * An object of route parameters.
  */
diff --git a/tests/js/route.test-d.ts b/tests/js/route.test-d.ts
index 425d169c..b8b55d56 100644
--- a/tests/js/route.test-d.ts
+++ b/tests/js/route.test-d.ts
@@ -1,5 +1,5 @@
 import { assertType } from 'vitest';
-import route, { RouteParams } from '../../src/js';
+import route from '../../src/js';
 
 // Add generated routes to use for testing inside this file. In a real app these declarations
 // would be in a separate file generated by running `php artisan ziggy:generate --types`.
@@ -15,8 +15,6 @@ declare module '../../src/js' {
     }
 }
 
-type T = RouteParams<'posts.comments.show'>;
-
 // Test route name autocompletion by adding quotes inside `route()` - should suggest route names above
 assertType(route());
 

From 2f368ea5f6964e4082a5255611fe35739510a9c8 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Fri, 22 Dec 2023 15:46:11 -0500
Subject: [PATCH 08/17] Formatting

---
 src/js/index.d.ts | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index b45ea5f6..d2f6cb54 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -61,7 +61,6 @@ type HasQueryParam = { _query?: Record<string, unknown> };
  */
 type GenericRouteParamsObject = Record<keyof any, unknown> & HasQueryParam;
 // `keyof any` essentially makes it function as a plain `Record`
-
 /**
  * An object of parameters for a specific named route.
  */
@@ -73,13 +72,11 @@ type KnownRouteParamsObject<I extends readonly ParameterInfo[]> = {
 // `readonly` allows TypeScript to determine the actual values of all the
 // parameter names inside the array, instead of just seeing `string`.
 // See https://github.com/tighten/ziggy/pull/664#discussion_r1329978447.
-
 // Uncomment to test:
 // type A = KnownRouteParamsObject<
 //     [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }]
 // >;
 // = { foo: ..., bar?: ... }
-
 /**
  * An object of route parameters.
  */

From bc026bbd29f393ac2bded2cef829abf416ab4474 Mon Sep 17 00:00:00 2001
From: Alex McCabe <alexwmccabe@gmail.com>
Date: Thu, 28 Dec 2023 15:37:17 +0000
Subject: [PATCH 09/17] Attempt to flatten types and improve error readibility

---
 src/js/index.d.ts | 47 +++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 39 insertions(+), 8 deletions(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index d2f6cb54..546a4726 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -52,6 +52,29 @@ type Routable<I extends ParameterInfo> = I extends { binding: string }
 // type B = Routable<{ name: 'foo' }>;
 // = RawParameterValue | DefaultRoutable
 
+type Input = [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }];
+
+type PartiallyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+type ArrToObj<I extends readonly ParameterInfo[]> = {
+    [T in I[number] as T['name']]: T;
+};
+
+type OptionalParams<I extends readonly ParameterInfo[]> = Extract<
+    I[number],
+    { optional: true }
+>['name'];
+
+type T<
+    TInfo extends readonly ParameterInfo[],
+    TOptionalKeys extends TInfo[number]['name'] = OptionalParams<TInfo>,
+    TInfoObj extends Record<string, ParameterInfo> = ArrToObj<TInfo>,
+> = {
+    [K in keyof PartiallyOptional<TInfoObj, TOptionalKeys>]: Routable<TInfoObj[K]>;
+};
+
+type F = T<Input>;
+
 /**
  * An object containing a special '_query' key to target the query string of a URL.
  */
@@ -64,18 +87,20 @@ type GenericRouteParamsObject = Record<keyof any, unknown> & HasQueryParam;
 /**
  * An object of parameters for a specific named route.
  */
-type KnownRouteParamsObject<I extends readonly ParameterInfo[]> = {
-    [T in Extract<I[number], { optional: false }> as T['name']]: Routable<T>;
-} & {
-    [T in Extract<I[number], { optional: true }> as T['name']]?: Routable<T>;
+type KnownRouteParamsObject<
+    TInfo extends readonly ParameterInfo[],
+    TOptionalKeys extends TInfo[number]['name'] = OptionalParams<TInfo>,
+    TInfoObj extends Record<string, ParameterInfo> = ArrToObj<TInfo>,
+> = {
+    [K in keyof PartiallyOptional<TInfoObj, TOptionalKeys>]: Routable<TInfoObj[K]>;
 } & GenericRouteParamsObject;
 // `readonly` allows TypeScript to determine the actual values of all the
 // parameter names inside the array, instead of just seeing `string`.
 // See https://github.com/tighten/ziggy/pull/664#discussion_r1329978447.
 // Uncomment to test:
-// type A = KnownRouteParamsObject<
-//     [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }]
-// >;
+type A = KnownRouteParamsObject<
+    [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }]
+>;
 // = { foo: ..., bar?: ... }
 /**
  * An object of route parameters.
@@ -117,7 +142,7 @@ type RouteParamsArray<N extends RouteName> = N extends KnownRouteName
 /**
  * All possible parameter argument shapes for a route.
  */
-type RouteParams<N extends RouteName> = ParameterValue | RouteParamsObject<N> | RouteParamsArray<N>;
+type RouteParams<N extends RouteName> = RouteParamsObject<N> | RouteParamsArray<N>;
 
 /**
  * A route.
@@ -169,6 +194,12 @@ export default function route<T extends RouteName>(
     absolute?: boolean,
     config?: Config,
 ): string;
+export default function route<T extends RouteName>(
+    name: T,
+    params?: ParameterValue | undefined,
+    absolute?: boolean,
+    config?: Config,
+): string;
 // Called with configuration arguments only - returns a configured Router instance
 export default function route(
     name: undefined,

From 700399d61f5d9abad7f41fa7123f727f7de9b7f7 Mon Sep 17 00:00:00 2001
From: Alex McCabe <alexwmccabe@gmail.com>
Date: Thu, 28 Dec 2023 15:47:48 +0000
Subject: [PATCH 10/17] Remove test code

---
 src/js/index.d.ts | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index 546a4726..0f32db4e 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -52,29 +52,16 @@ type Routable<I extends ParameterInfo> = I extends { binding: string }
 // type B = Routable<{ name: 'foo' }>;
 // = RawParameterValue | DefaultRoutable
 
-type Input = [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }];
-
+// Utility types for `KnownRouteParamsObject`:
 type PartiallyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-
 type ArrToObj<I extends readonly ParameterInfo[]> = {
     [T in I[number] as T['name']]: T;
 };
-
 type OptionalParams<I extends readonly ParameterInfo[]> = Extract<
     I[number],
     { optional: true }
 >['name'];
 
-type T<
-    TInfo extends readonly ParameterInfo[],
-    TOptionalKeys extends TInfo[number]['name'] = OptionalParams<TInfo>,
-    TInfoObj extends Record<string, ParameterInfo> = ArrToObj<TInfo>,
-> = {
-    [K in keyof PartiallyOptional<TInfoObj, TOptionalKeys>]: Routable<TInfoObj[K]>;
-};
-
-type F = T<Input>;
-
 /**
  * An object containing a special '_query' key to target the query string of a URL.
  */
@@ -98,9 +85,9 @@ type KnownRouteParamsObject<
 // parameter names inside the array, instead of just seeing `string`.
 // See https://github.com/tighten/ziggy/pull/664#discussion_r1329978447.
 // Uncomment to test:
-type A = KnownRouteParamsObject<
-    [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }]
->;
+// type A = KnownRouteParamsObject<
+//     [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }]
+// >;
 // = { foo: ..., bar?: ... }
 /**
  * An object of route parameters.

From 7cd9786949d9f4d68bee6b582f92b9b63aa6370c Mon Sep 17 00:00:00 2001
From: Alex McCabe <alexwmccabe@gmail.com>
Date: Thu, 28 Dec 2023 16:04:18 +0000
Subject: [PATCH 11/17] Fix failing 'Allow extra nested properties' test

---
 src/js/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index 0f32db4e..3df94446 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -43,7 +43,7 @@ type ParameterValue = RawParameterValue | DefaultRoutable;
  * A parseable route parameter, either plain or nested inside an object under its binding key.
  */
 type Routable<I extends ParameterInfo> = I extends { binding: string }
-    ? { [K in I['binding']]: RawParameterValue } | RawParameterValue
+    ? ({ [K in I['binding']]: RawParameterValue } & Record<string, unknown>) | RawParameterValue
     : ParameterValue;
 
 // Uncomment to test:

From b7ea5d8548d94076752b6b2c589f2e8752a732ec Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Mon, 25 Mar 2024 12:58:23 -0400
Subject: [PATCH 12/17] Wip

---
 src/Output/Types.php | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Output/Types.php b/src/Output/Types.php
index 43b7fc7a..55b2e774 100644
--- a/src/Output/Types.php
+++ b/src/Output/Types.php
@@ -3,6 +3,7 @@
 namespace Tighten\Ziggy\Output;
 
 use Illuminate\Support\Arr;
+use Illuminate\Support\Str;
 use Stringable;
 use Tighten\Ziggy\Ziggy;
 
@@ -20,8 +21,8 @@ public function __toString(): string
         $routes = collect($this->ziggy->toArray()['routes'])->map(function ($route) {
             return collect($route['parameters'] ?? [])->map(function ($param) use ($route) {
                 return Arr::has($route, "bindings.{$param}")
-                    ? ['name' => $param, 'optional' => strpos($route['uri'], "{$param}?") !== false, 'binding' => $route['bindings'][$param]]
-                    : ['name' => $param, 'optional' => strpos($route['uri'], "{$param}?") !== false];
+                    ? ['name' => $param, 'optional' => Str::contains($route['uri'], "{$param}?"), 'binding' => $route['bindings'][$param]]
+                    : ['name' => $param, 'optional' => Str::contains($route['uri'], "{$param}?")];
             });
         });
 

From b24a055a8ae9bd74272b0d928d802b5aaf227851 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Mon, 25 Mar 2024 13:06:34 -0400
Subject: [PATCH 13/17] Rename 'optional' to 'required'

---
 src/Output/Types.php        | 4 ++--
 src/js/index.d.ts           | 6 +++---
 tests/fixtures/ziggy-7.d.ts | 6 +++---
 tests/fixtures/ziggy.d.ts   | 6 +++---
 tests/js/route.test-d.ts    | 8 ++++----
 5 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/Output/Types.php b/src/Output/Types.php
index 55b2e774..6269c587 100644
--- a/src/Output/Types.php
+++ b/src/Output/Types.php
@@ -21,8 +21,8 @@ public function __toString(): string
         $routes = collect($this->ziggy->toArray()['routes'])->map(function ($route) {
             return collect($route['parameters'] ?? [])->map(function ($param) use ($route) {
                 return Arr::has($route, "bindings.{$param}")
-                    ? ['name' => $param, 'optional' => Str::contains($route['uri'], "{$param}?"), 'binding' => $route['bindings'][$param]]
-                    : ['name' => $param, 'optional' => Str::contains($route['uri'], "{$param}?")];
+                    ? ['name' => $param, 'required' => ! Str::contains($route['uri'], "{$param}?"), 'binding' => $route['bindings'][$param]]
+                    : ['name' => $param, 'required' => ! Str::contains($route['uri'], "{$param}?")];
             });
         });
 
diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index 5afb08ed..cacdb658 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -21,7 +21,7 @@ type RouteName = KnownRouteName | (string & {});
 /**
  * Information about a single route parameter.
  */
-type ParameterInfo = { name: string; optional: boolean; binding?: string };
+type ParameterInfo = { name: string; required: boolean; binding?: string };
 
 /**
  * A primitive route parameter value, as it would appear in a URL.
@@ -59,7 +59,7 @@ type ArrToObj<I extends readonly ParameterInfo[]> = {
 };
 type OptionalParams<I extends readonly ParameterInfo[]> = Extract<
     I[number],
-    { optional: true }
+    { required: false }
 >['name'];
 
 /**
@@ -86,7 +86,7 @@ type KnownRouteParamsObject<
 // See https://github.com/tighten/ziggy/pull/664#discussion_r1329978447.
 // Uncomment to test:
 // type A = KnownRouteParamsObject<
-//     [{ name: 'foo'; optional: false }, { name: 'bar'; optional: true }]
+//     [{ name: 'foo'; required: true }, { name: 'bar'; required: false }]
 // >;
 // = { foo: ..., bar?: ... }
 /**
diff --git a/tests/fixtures/ziggy-7.d.ts b/tests/fixtures/ziggy-7.d.ts
index 544aaac3..063e49b0 100644
--- a/tests/fixtures/ziggy-7.d.ts
+++ b/tests/fixtures/ziggy-7.d.ts
@@ -5,18 +5,18 @@ declare module 'ziggy-js' {
     "postComments.show": [
         {
             "name": "post",
-            "optional": false
+            "required": true
         },
         {
             "name": "comment",
-            "optional": false,
+            "required": true,
             "binding": "uuid"
         }
     ],
     "postComments.store": [
         {
             "name": "post",
-            "optional": false
+            "required": true
         }
     ]
 }
diff --git a/tests/fixtures/ziggy.d.ts b/tests/fixtures/ziggy.d.ts
index e98fb13f..1fc16919 100644
--- a/tests/fixtures/ziggy.d.ts
+++ b/tests/fixtures/ziggy.d.ts
@@ -5,17 +5,17 @@ declare module 'ziggy-js' {
     "postComments.store": [
         {
             "name": "post",
-            "optional": false
+            "required": true
         }
     ],
     "postComments.storeComment": [
         {
             "name": "post",
-            "optional": false
+            "required": true
         },
         {
             "name": "comment",
-            "optional": true
+            "required": false
         }
     ]
 }
diff --git a/tests/js/route.test-d.ts b/tests/js/route.test-d.ts
index a0676224..a8d103d2 100644
--- a/tests/js/route.test-d.ts
+++ b/tests/js/route.test-d.ts
@@ -6,12 +6,12 @@ import { route } from '../../src/js';
 declare module '../../src/js' {
     interface RouteList {
         'posts.index': [];
-        'posts.comments.store': [{ name: 'post'; optional: false }];
+        'posts.comments.store': [{ name: 'post'; required: true }];
         'posts.comments.show': [
-            { name: 'post'; optional: false },
-            { name: 'comment'; optional: true; binding: 'uuid' },
+            { name: 'post'; required: true },
+            { name: 'comment'; required: false; binding: 'uuid' },
         ];
-        optional: [{ name: 'maybe'; optional: true }];
+        optional: [{ name: 'maybe'; required: false }];
     }
 }
 

From 02e5ab78410aed8530db2164411ae398a9c15325 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Mon, 25 Mar 2024 13:57:27 -0400
Subject: [PATCH 14/17] Refactor and simplify utility types

---
 src/js/index.d.ts | 32 ++++++++++++--------------------
 1 file changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index cacdb658..e2ccdf2d 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -52,15 +52,9 @@ type Routable<I extends ParameterInfo> = I extends { binding: string }
 // type B = Routable<{ name: 'foo' }>;
 // = RawParameterValue | DefaultRoutable
 
-// Utility types for `KnownRouteParamsObject`:
-type PartiallyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-type ArrToObj<I extends readonly ParameterInfo[]> = {
-    [T in I[number] as T['name']]: T;
-};
-type OptionalParams<I extends readonly ParameterInfo[]> = Extract<
-    I[number],
-    { required: false }
->['name'];
+// Utility types for KnownRouteParamsObject
+type RequiredParams<I extends readonly ParameterInfo[]> = Extract<I[number], { required: true }>;
+type OptionalParams<I extends readonly ParameterInfo[]> = Extract<I[number], { required: false }>;
 
 /**
  * An object containing a special '_query' key to target the query string of a URL.
@@ -74,21 +68,19 @@ type GenericRouteParamsObject = Record<keyof any, unknown> & HasQueryParam;
 /**
  * An object of parameters for a specific named route.
  */
-type KnownRouteParamsObject<
-    TInfo extends readonly ParameterInfo[],
-    TOptionalKeys extends TInfo[number]['name'] = OptionalParams<TInfo>,
-    TInfoObj extends Record<string, ParameterInfo> = ArrToObj<TInfo>,
-> = {
-    [K in keyof PartiallyOptional<TInfoObj, TOptionalKeys>]: Routable<TInfoObj[K]>;
+type KnownRouteParamsObject<I extends readonly ParameterInfo[]> = {
+    [T in RequiredParams<I> as T['name']]: Routable<T>;
+} & {
+    [T in OptionalParams<I> as T['name']]?: Routable<T>;
 } & GenericRouteParamsObject;
 // `readonly` allows TypeScript to determine the actual values of all the
 // parameter names inside the array, instead of just seeing `string`.
 // See https://github.com/tighten/ziggy/pull/664#discussion_r1329978447.
+
 // Uncomment to test:
-// type A = KnownRouteParamsObject<
-//     [{ name: 'foo'; required: true }, { name: 'bar'; required: false }]
-// >;
-// = { foo: ..., bar?: ... }
+// type A = KnownRouteParamsObject<[{ name: 'foo'; required: true }, { name: 'bar'; required: false }]>;
+// = { foo: ... } & { bar?: ... }
+
 /**
  * An object of route parameters.
  */
@@ -181,7 +173,7 @@ export function route<T extends RouteName>(
     absolute?: boolean,
     config?: Config,
 ): string;
-export default function route<T extends RouteName>(
+export function route<T extends RouteName>(
     name: T,
     params?: ParameterValue | undefined,
     absolute?: boolean,

From 13b395e7f23e03ae03b4a0c2b4f735f17262f854 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Mon, 25 Mar 2024 14:08:39 -0400
Subject: [PATCH 15/17] Add more type tests

---
 tests/js/route.test-d.ts | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/js/route.test-d.ts b/tests/js/route.test-d.ts
index a8d103d2..1930188b 100644
--- a/tests/js/route.test-d.ts
+++ b/tests/js/route.test-d.ts
@@ -49,10 +49,20 @@ assertType(route('posts.comments.show', { comment: { foo: 'bar' } }));
 // parameter has an explicit 'uuid' binding, so that's required :)
 assertType(route('posts.comments.show', { comment: { id: 2 } }));
 
+// Plain values
+assertType(route('posts.comments.show', 2));
+assertType(route('posts.comments.show', 'foo'));
+
+// TODO @ts-expect-error parameter argument itself is required
+assertType(route('posts.comments.show'));
+
 // Simple array examples
+assertType(route('posts.comments.show', [2]));
 assertType(route('posts.comments.show', [2, 3]));
+assertType(route('posts.comments.show', ['foo']));
 assertType(route('posts.comments.show', ['foo', 'bar']));
 // Allows mix of plain values and parameter objects
+assertType(route('posts.comments.show', [{ id: 2 }]));
 assertType(route('posts.comments.show', [{ id: 2 }, 3]));
 assertType(route('posts.comments.show', ['2', { uuid: 3 }]));
 assertType(route('posts.comments.show', [{ id: 2 }, { uuid: '3' }]));
@@ -78,3 +88,12 @@ assertType(route().has(''));
 
 // Test router getter autocompletion
 assertType(route().params);
+
+assertType(route().current('missing', { foo: 1 }));
+
+// @ts-expect-error missing required 'post' parameter
+assertType(route().current('posts.comments.show', { comment: 2 }));
+assertType(route().current('posts.comments.show', { post: 2 }));
+assertType(route().current('posts.comments.show', 2));
+assertType(route().current('posts.comments.show', [2]));
+assertType(route().current('posts.comments.show', 'foo'));

From 2ea950f76928de479917127347582f4a3bf4ebfa Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Mon, 25 Mar 2024 14:09:32 -0400
Subject: [PATCH 16/17] Fix passing raw params to `current()`

---
 src/js/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index e2ccdf2d..72789c89 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -156,7 +156,7 @@ interface Config {
  */
 interface Router {
     current(): RouteName | undefined;
-    current<T extends RouteName>(name: T, params?: RouteParams<T>): boolean;
+    current<T extends RouteName>(name: T, params?: ParameterValue | RouteParams<T>): boolean;
     get params(): Record<string, unknown>;
     has<T extends RouteName>(name: T): boolean;
 }

From bc1ce2bd652d4919764dc6b38bd8586b37dbfbb1 Mon Sep 17 00:00:00 2001
From: Jacob Baker-Kretzmar <jacobtbk@gmail.com>
Date: Mon, 25 Mar 2024 14:16:14 -0400
Subject: [PATCH 17/17] Wip

---
 src/js/index.d.ts        | 8 ++++----
 tests/js/route.test-d.ts | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/js/index.d.ts b/src/js/index.d.ts
index 72789c89..bf0c5dcc 100644
--- a/src/js/index.d.ts
+++ b/src/js/index.d.ts
@@ -43,13 +43,13 @@ type ParameterValue = RawParameterValue | DefaultRoutable;
  * A parseable route parameter, either plain or nested inside an object under its binding key.
  */
 type Routable<I extends ParameterInfo> = I extends { binding: string }
-    ? ({ [K in I['binding']]: RawParameterValue } & Record<string, unknown>) | RawParameterValue
+    ? ({ [K in I['binding']]: RawParameterValue } & Record<keyof any, unknown>) | RawParameterValue
     : ParameterValue;
 
 // Uncomment to test:
-// type A = Routable<{ name: 'foo', binding: 'bar' }>;
+// type A = Routable<{ name: 'foo', required: true, binding: 'bar' }>;
 // = RawParameterValue | { bar: RawParameterValue }
-// type B = Routable<{ name: 'foo' }>;
+// type B = Routable<{ name: 'foo', required: true, }>;
 // = RawParameterValue | DefaultRoutable
 
 // Utility types for KnownRouteParamsObject
@@ -108,7 +108,7 @@ type KnownRouteParamsArray<I extends readonly ParameterInfo[]> = [
 // See https://github.com/tighten/ziggy/pull/664#discussion_r1330002370.
 
 // Uncomment to test:
-// type B = KnownRouteParamsArray<[{ name: 'post', binding: 'uuid' }]>;
+// type B = KnownRouteParamsArray<[{ name: 'post'; required: true; binding: 'uuid' }]>;
 // = [RawParameterValue | { uuid: RawParameterValue }, ...unknown[]]
 
 /**
diff --git a/tests/js/route.test-d.ts b/tests/js/route.test-d.ts
index 1930188b..7d6ca792 100644
--- a/tests/js/route.test-d.ts
+++ b/tests/js/route.test-d.ts
@@ -57,12 +57,12 @@ assertType(route('posts.comments.show', 'foo'));
 assertType(route('posts.comments.show'));
 
 // Simple array examples
-assertType(route('posts.comments.show', [2]));
+// assertType(route('posts.comments.show', [2])); // TODO shouldn't error, only one required param
 assertType(route('posts.comments.show', [2, 3]));
-assertType(route('posts.comments.show', ['foo']));
+// assertType(route('posts.comments.show', ['foo'])); // TODO shouldn't error, only one required param
 assertType(route('posts.comments.show', ['foo', 'bar']));
 // Allows mix of plain values and parameter objects
-assertType(route('posts.comments.show', [{ id: 2 }]));
+// assertType(route('posts.comments.show', [{ id: 2 }])); // TODO shouldn't error, only one required param
 assertType(route('posts.comments.show', [{ id: 2 }, 3]));
 assertType(route('posts.comments.show', ['2', { uuid: 3 }]));
 assertType(route('posts.comments.show', [{ id: 2 }, { uuid: '3' }]));
@@ -95,5 +95,5 @@ assertType(route().current('missing', { foo: 1 }));
 assertType(route().current('posts.comments.show', { comment: 2 }));
 assertType(route().current('posts.comments.show', { post: 2 }));
 assertType(route().current('posts.comments.show', 2));
-assertType(route().current('posts.comments.show', [2]));
+// assertType(route().current('posts.comments.show', [2])); // TODO shouldn't error, only one required param
 assertType(route().current('posts.comments.show', 'foo'));