Provide an official runtime route-existence primitive

[niels-numbers]

Hi - I'm wrapping the generated route() from LaravelRouteTransformedProvider for a locale-aware routing package and wanted to flag an API gap I think a few people will hit.

Context

Locale-routing packages (niels-numbers/laravel-localizer, the recommended successor to mcamara/laravel-localization with ~8M downloads, and codezero-be/laravel-localized-routes) register a single user-facing name like about as several internal route names. A JS wrapper around your route() needs to ask "which variant exists in the manifest?" - the equivalent of Route::has(...) server-side.

Today

There's a workable workaround: since the generated route() does '/' + routes[name] and falls through to '/undefined' when the name is missing, wrappers can detect existence by inspecting the return value:

function exists(name: string): boolean {
    return route(name as RouteName, {}, /* absolute */ false) !== '/undefined';
}

This is what I'm shipping for now. But it relies on the current body of the generated route() - if you ever change the miss handling (throw, return '', etc.), every wrapper that depends on it breaks silently. The generator already has the right object to make this explicit:

const routes = { ... };           // module-local, no export
type RouteParameters = { ... };   // module-local, no export
export function route(...) { ... }

Only route() is exported ([source][1]: 4th Transformed constructor argument is the export flag, false for the first two).

Proposal

Either, whichever fits the design:

(a) Flip the $export flag on $transformedRoutes so routes becomes a named export. Wrappers check name in routes instead of the string-marker hack.

(b) Emit export function routeExists(name: keyof RouteParameters): boolean alongside route(). Keeps the lookup object's shape an implementation detail but gives downstream code a contract to depend on.

Both are purely additive: no change to the existing route() signature, no impact on users who only do import {route} from './helpers/route'. Happy to send a PR for either.

Thanks!

[yudin-s]

I think routeExists(name) is the cleaner API than exporting the raw routes object.

The current /undefined workaround depends on an implementation detail of route(). That is exactly the kind of thing that works until the generator improves its missing-route behavior and silently breaks wrappers.

An additive helper keeps the manifest shape private:

export function routeExists(name: keyof RouteParameters): boolean {
  return Object.prototype.hasOwnProperty.call(routes, name)
}

For locale wrappers, that gives a stable contract:

const localized = `${locale}.${name}` as keyof RouteParameters

if (routeExists(localized)) {
  return route(localized, params)
}

return route(name, params)

The main typing caveat is dynamic string input. If a wrapper receives arbitrary strings, it may need a looser overload:

routeExists(name: string): name is keyof RouteParameters

That would be very useful because it narrows the type before calling route().

So my vote would be option B: export routeExists() and keep routes module-local. It is smaller API surface, avoids depending on object shape, and maps directly to Laravel's Route::has(...) mental model.