add match function

README.md

@@ -203,6 +203,29 @@ route().params; // { venue: '1', event: '2', hosts: 'all' }
 
 > Note: parameter values retrieved with `route().params` will always be returned as strings.
 
+#### Match url to get route name and params
+
+```js
+// Laravel route called 'post.update' with URI '/post/{post}'
+// axios response.request.responseURL is https://myapp.com/post/1
+
+route().match('/myapp.com/post/1');
+/* result:
+ *  {
+ *      name: 'posts.update',
+ *      params: {post: '1'},
+ *      query: {},
+ *      route: {
+ *          uri: 'posts/{post}',
+ *          methods: ['PUT'],
+ *          bindings: {
+ *              post: 'id',
+ *          },
+ *      },
+ *  }
+*/
+```
+
 ### Route-model binding
 
 Ziggy supports Laravel's [route-model binding](https://laravel.com/docs/routing#route-model-binding), and can even recognize custom route key names. If you pass `route()` a JavaScript object as a route parameter, Ziggy will use the registered route-model binding keys for that route to find the correct parameter value inside the object. If no route-model binding keys are explicitly registered for a parameter, Ziggy will use the object's `id` key.

src/js/Route.js

@@ -74,8 +74,8 @@ export default class Route {
      * @param {String} url - URL to check.
      * @return {Object|false} - If this route matches, returns the matched parameters.
      */
-    matchesUrl(url) {
-        if (!this.definition.methods.includes('GET')) return false;
+    matchesUrl(url, method = 'GET') {
+        if (!this.definition.methods.includes(method.toUpperCase())) return false;
 
         // Transform the route's template into a regex that will match a hydrated URL,
         // by replacing its parameter segments with matchers for parameter values

src/js/Router.js

@@ -65,7 +65,7 @@ export default class Router extends String {
      * @param {String} [url] - The URL to inspect, defaults to the current window URL.
      * @return {{ name: string, params: Object, query: Object, route: Route }}
      */
-    _unresolve(url) {
+    match(url, method='GET') {
         if (!url) {
             url = this._currentUrl();
         } else if (this._config.absolute && url.startsWith('/')) {
@@ -77,7 +77,7 @@ export default class Router extends String {
         let matchedParams = {};
         const [name, route] = Object.entries(this._config.routes).find(
             ([name, route]) =>
-                (matchedParams = new Route(name, route, this._config).matchesUrl(url)),
+                (matchedParams = new Route(name, route, this._config).matchesUrl(url, method)),
         ) || [undefined, undefined];
 
         return { name, ...matchedParams, route };
@@ -112,7 +112,7 @@ export default class Router extends String {
      * @return {(Boolean|String|undefined)}
      */
     current(name, params) {
-        const { name: current, params: currentParams, query, route } = this._unresolve();
+        const { name: current, params: currentParams, query, route } = this.match();
 
         // If a name wasn't passed, return the name of the current route
         if (!name) return current;
@@ -191,17 +191,17 @@ export default class Router extends String {
      * @return {Object}
      */
     get params() {
-        const { params, query } = this._unresolve();
+        const { params, query } = this.match();
 
         return { ...params, ...query };
     }
 
     get routeParams() {
-        return this._unresolve().params;
+        return this.match().params;
     }
 
     get queryParams() {
-        return this._unresolve().query;
+        return this.match().query;
     }
 
     /**

tests/js/route.test.js

@@ -1503,3 +1503,42 @@ describe('current()', () => {
         global.window = oldWindow;
     });
 });
+
+describe('match()', () => {
+    test('can get routes PUT requests', () => {
+        expect(route().match('ziggy.dev/posts/1', 'PUT')).toEqual({
+            name: 'posts.update',
+            params: {post: '1'},
+            query: {},
+            route: {
+                uri: 'posts/{post}',
+                methods: ['PUT'],
+                bindings: {
+                    post: 'id',
+                },
+            },
+        });
+    });
+
+    test('can ignore routes that don’t allow PUT requests', () => {
+        expect(route().match('ziggy.dev/hosting-contacts', 'PUT')).toEqual({
+            name: undefined,
+            route: undefined
+        });
+    });
+
+    test('can get routes PUT requests by lower case', () => {
+        expect(route().match('ziggy.dev/posts/1', 'put')).toEqual({
+            name: 'posts.update',
+            params: {post: '1'},
+            query: {},
+            route: {
+                uri: 'posts/{post}',
+                methods: ['PUT'],
+                bindings: {
+                    post: 'id',
+                },
+            },
+        });
+    });
+});