ziggy-js 1.7.1 → 1.8.0

package/README.md

@@ -17,7 +17,7 @@ Ziggy supports all versions of Laravel from `5.4` onward, and all modern browser
     - [The `route()` helper](#the-route-helper)
     - [The `Router` class](#the-router-class)
     - [Route-model binding](#route-model-binding)
-    - [TypeScript support](#typescript-support)
+    - [TypeScript](#typescript)
 - [**Advanced Setup**](#advanced-setup)
     - [JavaScript frameworks](#javascript-frameworks)
     - [Vue](#vue)
@@ -31,7 +31,11 @@ Ziggy supports all versions of Laravel from `5.4` onward, and all modern browser
 
 ## Installation
 
-Install Ziggy into your Laravel app with `composer require tightenco/ziggy`.
+Install Ziggy in your Laravel app:
+
+```bash
+composer require tightenco/ziggy
+```
 
 Add the `@routes` Blade directive to your main layout (_before_ your application's JavaScript), and the `route()` helper function will now be available globally!
 
@@ -281,9 +285,37 @@ route('authors.photos.show', [{ id: 1, name: 'Jacob' }, photo]);
 // 'https://ziggy.test/authors/1/photos/714b19e8-ac5e-4dab-99ba-34dc6fdd24a5'
 ```
 
-#### TypeScript support
+#### TypeScript
+
+Ziggy includes TypeScript type definitions, and a helper command that can generate additional type definitions to enable route name and parameter autocompletion.
+
+To generate the route types, run Ziggy's Artisan command with the `--types` or `--types-only` option:
+
+```bash
+php artisan ziggy:generate --types
+```
+
+To make your IDE aware that Ziggy's `route()` helper is available globally, and to type it correctly, add a declaration like this in a `.d.ts` file somewhere in your project:
+
+```ts
+import routeFn from 'ziggy-js';
+
+declare global {
+    var route: typeof routeFn;
+}
+```
+
+If you don't have Ziggy's NPM package installed, add the following to your `jsconfig.json` or `tsconfig.json` to load Ziggy's types from the Composer vendor directory:
 
-Unofficial TypeScript type definitions for Ziggy are maintained by [benallfree](https://github.com/benallfree) as part of [Definitely Typed](https://github.com/DefinitelyTyped/DefinitelyTyped), and can be installed with `npm install @types/ziggy-js`.
+```json
+{
+    "compilerOptions": {
+        "paths": {
+            "ziggy-js": ["./vendor/tightenco/ziggy"]
+        }
+    }
+}
+```
 
 ## Advanced Setup
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ziggy-js",
-    "version": "1.7.1",
+    "version": "1.8.0",
     "description": "Use your Laravel named routes in JavaScript.",
     "keywords": [
         "laravel",
@@ -25,7 +25,7 @@
         }
     ],
     "files": [
-        "src/js",
+        "src/js/index.d.ts",
         "dist"
     ],
     "source": "src/js/index.js",
@@ -35,18 +35,19 @@
     "browser": "dist/index.js",
     "module": "dist/index.m.js",
     "esmodule": "dist/index.es.js",
+    "types": "src/js/index.d.ts",
     "repository": {
         "type": "git",
         "url": "https://github.com/tighten/ziggy.git"
     },
     "scripts": {
-        "build": "microbundle --name route --format modern,es,umd --external none --no-sourcemap",
-        "build:vue": "microbundle --entry src/js/vue.js --output dist/vue.js --name ZiggyVue --format modern,es,umd --external none --no-sourcemap",
-        "build:react": "microbundle --entry src/js/react.js --output dist/react.js --name ZiggyReact --format modern,es,umd --external none --no-sourcemap",
+        "build": "microbundle --name route --format modern,es,umd --external none --no-sourcemap --no-generateTypes",
+        "build:vue": "microbundle --entry src/js/vue.js --output dist/vue.js --name ZiggyVue --format modern,es,umd --external none --no-sourcemap --no-generateTypes",
+        "build:react": "microbundle --entry src/js/react.js --output dist/react.js --name ZiggyReact --format modern,es,umd --external none --no-sourcemap --no-generateTypes",
         "watch": "npm run build watch",
-        "build:npm": "microbundle --name route --format modern,es,umd --no-sourcemap",
-        "build:npm:vue": "microbundle --entry src/js/vue.js --output dist/vue.js --name ZiggyVue --format modern,es,umd --no-sourcemap",
-        "build:npm:react": "microbundle --entry src/js/react.js --output dist/react.js --name ZiggyReact --format modern,es,umd --no-sourcemap",
+        "build:npm": "microbundle --name route --format modern,es,umd --no-sourcemap --no-generateTypes",
+        "build:npm:vue": "microbundle --entry src/js/vue.js --output dist/vue.js --name ZiggyVue --format modern,es,umd --no-sourcemap --no-generateTypes",
+        "build:npm:react": "microbundle --entry src/js/react.js --output dist/react.js --name ZiggyReact --format modern,es,umd --no-sourcemap --no-generateTypes",
         "test": "jest --verbose",
         "prepublishOnly": "npm run build:npm && npm run build:npm:vue && npm run build:npm:react"
     },

package/src/js/index.d.ts

@@ -0,0 +1,163 @@
+/**
+ * A list of routes and their parameters and bindings.
+ *
+ * Extended and filled by the route list generated with `php artisan ziggy:generate --types`.
+ */
+export interface RouteList {}
+
+/**
+ * A route name registered with Ziggy.
+ */
+type KnownRouteName = keyof RouteList;
+
+/**
+ * A route name, or any string.
+ */
+type RouteName = KnownRouteName | (string & {});
+// `(string & {})` prevents TypeScript from reducing this type to just `string`,
+// which would prevent intellisense from autocompleting known route names.
+// See https://stackoverflow.com/a/61048124/6484459.
+
+/**
+ * Information about a single route parameter.
+ */
+type ParameterInfo = { name: string, binding?: string };
+
+/**
+ * A primitive route parameter value, as it would appear in a URL.
+ */
+type RawParameterValue = string | number;
+// TODO: Technically booleans work too, does it make sense to add them? Here? What would that look like?
+
+/**
+ * An object parameter value containing the 'default' binding key `id`, e.g. representing an Eloquent model.
+ */
+type DefaultRoutable = { id: RawParameterValue } & Record<keyof any, unknown>;
+
+/**
+ * A route parameter value.
+ */
+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
+    : ParameterValue;
+
+// Uncomment to test:
+// type A = Routable<{ name: 'foo', binding: 'bar' }>;
+// = RawParameterValue | { bar: RawParameterValue }
+// type B = Routable<{ name: 'foo' }>;
+// = RawParameterValue | DefaultRoutable
+
+/**
+ * An object containing a special '_query' key to target the query string of a URL.
+ */
+type HasQueryParam = { _query?: Record<string, unknown> };
+/**
+ * An object of parameters for an unspecified route.
+ */
+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.
+ */
+// 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> } & 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.
+/**
+ * An object of route parameters.
+ */
+type RouteParamsObject<N extends RouteName> = N extends KnownRouteName ? KnownRouteParamsObject<RouteList[N]> : GenericRouteParamsObject;
+
+/**
+ * An array of parameters for an unspecified route.
+ */
+// TODO: this may be able to be more specific, like `Routable<ParameterInfo>[]`,
+// depending how we want to handle nested objects inside parameter arrays
+type GenericRouteParamsArray = unknown[];
+/**
+ * An array of parameters for a specific named route.
+ */
+type KnownRouteParamsArray<I extends readonly ParameterInfo[]> = [...{ [K in keyof I]: Routable<I[K]> }, ...unknown[]];
+// Because `K in keyof I` for a `readonly` array is always a number, even though this
+// looks like `{ 0: T, 1: U, 2: V }` TypeScript generates `[T, U, V]`. The nested
+// array destructing lets us type the first n items in the array, which are known
+// route parameters, and then allow arbitrary additional items.
+// See https://github.com/tighten/ziggy/pull/664#discussion_r1330002370.
+
+// Uncomment to test:
+// type B = KnownRouteParamsArray<[{ name: 'post', binding: 'uuid' }]>;
+// = [RawParameterValue | { uuid: RawParameterValue }, ...unknown[]]
+
+/**
+ * An array of route parameters.
+ */
+type RouteParamsArray<N extends RouteName> = N extends KnownRouteName ? KnownRouteParamsArray<RouteList[N]> : GenericRouteParamsArray;
+
+/**
+ * All possible parameter argument shapes for a route.
+ */
+type RouteParams<N extends RouteName> = ParameterValue | RouteParamsObject<N> | RouteParamsArray<N>;
+
+/**
+ * A route.
+ */
+interface Route {
+    uri: string,
+    methods: ('GET' | 'HEAD' | 'POST' | 'PATCH' | 'PUT' | 'OPTIONS' | 'DELETE')[],
+    domain?: string,
+    parameters?: string[],
+    bindings?: Record<string, string>,
+    wheres?: Record<string, unknown>,
+    middleware?: string[],
+}
+
+/**
+ * Ziggy's config object.
+ */
+interface Config {
+    url: string,
+    port: number | null,
+    defaults: Record<string, RawParameterValue>,
+    routes: Record<string, Route>,
+    location?: {
+        host?: string,
+        pathname?: string,
+        search?: string,
+    },
+}
+
+/**
+ * Ziggy's Router class.
+ */
+interface Router {
+    current(): RouteName | undefined,
+    current<T extends RouteName>(name: T, params?: RouteParams<T>): boolean,
+    get params(): Record<string, unknown>,
+    has<T extends RouteName>(name: T): boolean,
+}
+
+/**
+ * Ziggy's route helper.
+ */
+// Called with no arguments - returns a Router instance
+export default function route(): Router;
+// Called with a route name and optional additional arguments - returns a URL string
+export default function route<T extends RouteName>(
+    name: T,
+    params?: RouteParams<T> | undefined,
+    absolute?: boolean,
+    config?: Config,
+): string;
+// Called with configuration arguments only - returns a configured Router instance
+export default function route(
+    name: undefined,
+    params: undefined,
+    absolute?: boolean,
+    config?: Config,
+): Router;

package/src/js/Route.js

@@ -1,123 +0,0 @@
-import { parse } from 'qs';
-
-/**
- * A Laravel route. This class represents one route and its configuration and metadata.
- */
-export default class Route {
-    /**
-     * @param {String} name - Route name.
-     * @param {Object} definition - Route definition.
-     * @param {Object} config - Ziggy configuration.
-     */
-    constructor(name, definition, config) {
-        this.name = name;
-        this.definition = definition;
-        this.bindings = definition.bindings ?? {};
-        this.wheres = definition.wheres ?? {};
-        this.config = config;
-    }
-
-    /**
-     * Get a 'template' of the complete URL for this route.
-     *
-     * @example
-     * https://{team}.ziggy.dev/user/{user}
-     *
-     * @return {String} Route template.
-     */
-    get template() {
-        const template = `${this.origin}/${this.definition.uri}`.replace(/\/+$/, '');
-
-        return template === '' ? '/' : template;
-    }
-
-    /**
-     * Get a template of the origin for this route.
-     *
-     * @example
-     * https://{team}.ziggy.dev/
-     *
-     * @return {String} Route origin template.
-     */
-    get origin() {
-        // If  we're building just a path there's no origin, otherwise: if this route has a
-        // domain configured we construct the origin with that, if not we use the app URL
-        return !this.config.absolute ? '' : this.definition.domain
-            ? `${this.config.url.match(/^\w+:\/\//)[0]}${this.definition.domain}${this.config.port ? `:${this.config.port}` : ''}`
-            : this.config.url;
-    }
-
-    /**
-     * Get an array of objects representing the parameters that this route accepts.
-     *
-     * @example
-     * [{ name: 'team', required: true }, { name: 'user', required: false }]
-     *
-     * @return {Array} Parameter segments.
-     */
-    get parameterSegments() {
-        return this.template.match(/{[^}?]+\??}/g)?.map((segment) => ({
-            name: segment.replace(/{|\??}/g, ''),
-            required: !/\?}$/.test(segment),
-        })) ?? [];
-    }
-
-    /**
-     * Get whether this route's template matches the given URL.
-     *
-     * @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;
-
-        // Transform the route's template into a regex that will match a hydrated URL,
-        // by replacing its parameter segments with matchers for parameter values
-        const pattern = this.template
-            .replace(/(\/?){([^}?]*)(\??)}/g, (_, slash, segment, optional) => {
-                const regex = `(?<${segment}>${this.wheres[segment]?.replace(/(^\^)|(\$$)/g, '') || '[^/?]+'})`;
-                return optional ? `(${slash}${regex})?` : `${slash}${regex}`;
-            })
-            .replace(/^\w+:\/\//, '');
-
-        const [location, query] = url.replace(/^\w+:\/\//, '').split('?');
-
-        const matches = new RegExp(`^${pattern}/?$`).exec(location);
-
-        if (matches) {
-            for (const k in matches.groups) {
-                matches.groups[k] = typeof matches.groups[k] === 'string' ? decodeURIComponent(matches.groups[k]) : matches.groups[k];
-            }
-            return { params: matches.groups, query: parse(query) };
-        }
-
-        return false;
-    }
-
-    /**
-     * Hydrate and return a complete URL for this route with the given parameters.
-     *
-     * @param {Object} params
-     * @return {String}
-     */
-    compile(params) {
-        const segments = this.parameterSegments;
-
-        if (!segments.length) return this.template;
-
-        return this.template.replace(/{([^}?]+)(\??)}/g, (_, segment, optional) => {
-            // If the parameter is missing but is not optional, throw an error
-            if (!optional && [null, undefined].includes(params[segment])) {
-                throw new Error(`Ziggy error: '${segment}' parameter is required for route '${this.name}'.`)
-            }
-
-            if (this.wheres[segment]) {
-                if (!new RegExp(`^${optional ? `(${this.wheres[segment]})?` : this.wheres[segment]}$`).test(params[segment] ?? '')) {
-                    throw new Error(`Ziggy error: '${segment}' parameter does not match required format '${this.wheres[segment]}' for route '${this.name}'.`)
-                }
-            }
-
-            return encodeURI(params[segment] ?? '').replace(/%7C/g, '|').replace(/%25/g, '%').replace(/\$/g, '%24');
-        }).replace(`${this.origin}//`, `${this.origin}/`).replace(/\/+$/, '');
-    }
-}

package/src/js/Router.js

@@ -1,275 +0,0 @@
-import { stringify } from 'qs';
-import Route from './Route';
-
-/**
- * A collection of Laravel routes. This class constitutes Ziggy's main API.
- */
-export default class Router extends String {
-    /**
-     * @param {String} [name] - Route name.
-     * @param {(String|Number|Array|Object)} [params] - Route parameters.
-     * @param {Boolean} [absolute] - Whether to include the URL origin.
-     * @param {Object} [config] - Ziggy configuration.
-     */
-    constructor(name, params, absolute = true, config) {
-        super();
-
-        this._config = config ?? (typeof Ziggy !== 'undefined' ? Ziggy : globalThis?.Ziggy);
-        this._config = { ...this._config, absolute };
-
-        if (name) {
-            if (!this._config.routes[name]) {
-                throw new Error(`Ziggy error: route '${name}' is not in the route list.`);
-            }
-
-            this._route = new Route(name, this._config.routes[name], this._config);
-            this._params = this._parse(params);
-        }
-    }
-
-    /**
-     * Get the compiled URL string for the current route and parameters.
-     *
-     * @example
-     * // with 'posts.show' route 'posts/{post}'
-     * (new Router('posts.show', 1)).toString(); // 'https://ziggy.dev/posts/1'
-     *
-     * @return {String}
-     */
-    toString() {
-        // Get parameters that don't correspond to any route segments to append them to the query
-        const unhandled = Object.keys(this._params)
-            .filter((key) => !this._route.parameterSegments.some(({ name }) => name === key))
-            .filter((key) => key !== '_query')
-            .reduce((result, current) => ({ ...result, [current]: this._params[current] }), {});
-
-        return this._route.compile(this._params) + stringify({ ...unhandled, ...this._params['_query'] }, {
-            addQueryPrefix: true,
-            arrayFormat: 'indices',
-            encodeValuesOnly: true,
-            skipNulls: true,
-            encoder: (value, encoder) => typeof value === 'boolean' ? Number(value) : encoder(value),
-        });
-    }
-
-    /**
-     * Get the parameters, values, and metadata from the given URL.
-     *
-     * @param {String} [url] - The URL to inspect, defaults to the current window URL.
-     * @return {{ name: string, params: Object, query: Object, route: Route }}
-     */
-    _unresolve(url) {
-        if (!url) {
-            url = this._currentUrl();
-        } else if (this._config.absolute && url.startsWith('/')) {
-            // If we are using absolute URLs and a relative URL
-            // is passed, prefix the host to make it absolute
-            url = this._location().host + url;
-        }
-
-        let matchedParams = {};
-        const [name, route] = Object.entries(this._config.routes).find(
-          ([name, route]) => (matchedParams = new Route(name, route, this._config).matchesUrl(url))
-        ) || [undefined, undefined];
-
-        return { name, ...matchedParams, route };
-    }
-
-    _currentUrl() {
-        const { host, pathname, search } = this._location();
-
-        return (
-            this._config.absolute
-                ? host + pathname
-                : pathname.replace(this._config.url.replace(/^\w*:\/\/[^/]+/, ''), '').replace(/^\/+/, '/')
-        ) + search;
-    }
-
-    /**
-     * Get the name of the route matching the current window URL, or, given a route name
-     * and parameters, check if the current window URL and parameters match that route.
-     *
-     * @example
-     * // at URL https://ziggy.dev/posts/4 with 'posts.show' route 'posts/{post}'
-     * route().current(); // 'posts.show'
-     * route().current('posts.index'); // false
-     * route().current('posts.show'); // true
-     * route().current('posts.show', { post: 1 }); // false
-     * route().current('posts.show', { post: 4 }); // true
-     *
-     * @param {String} [name] - Route name to check.
-     * @param {(String|Number|Array|Object)} [params] - Route parameters.
-     * @return {(Boolean|String|undefined)}
-     */
-    current(name, params) {
-        const { name: current, params: currentParams, query, route } = this._unresolve();
-
-        // If a name wasn't passed, return the name of the current route
-        if (!name) return current;
-
-        // Test the passed name against the current route, matching some
-        // basic wildcards, e.g. passing `events.*` matches `events.show`
-        const match = new RegExp(`^${name.replace(/\./g, '\\.').replace(/\*/g, '.*')}$`).test(current);
-
-        if ([null, undefined].includes(params) || !match) return match;
-
-        const routeObject = new Route(current, route, this._config);
-
-        params = this._parse(params, routeObject);
-        const routeParams = { ...currentParams, ...query };
-
-        // If the current window URL has no route parameters, and the passed parameters are empty, return true
-        if (Object.values(params).every(p => !p) && !Object.values(routeParams).some(v => v !== undefined)) return true;
-
-        // Check that all passed parameters match their values in the current window URL
-        // Use weak equality because all values in the current window URL will be strings
-        return Object.entries(params).every(([key, value]) => routeParams[key] == value);
-    }
-
-    /**
-     * Get an object representing the current location (by default this will be
-     * the JavaScript `window` global if it's available).
-     *
-     * @return {Object}
-     */
-    _location() {
-        const { host = '', pathname = '', search = '' } = typeof window !== 'undefined' ? window.location : {};
-
-        return {
-            host: this._config.location?.host ?? host,
-            pathname: this._config.location?.pathname ?? pathname,
-            search: this._config.location?.search ?? search,
-        };
-    }
-
-    /**
-     * Get all parameter values from the current window URL.
-     *
-     * @example
-     * // at URL https://tighten.ziggy.dev/posts/4?lang=en with 'posts.show' route 'posts/{post}' and domain '{team}.ziggy.dev'
-     * route().params; // { team: 'tighten', post: 4, lang: 'en' }
-     *
-     * @return {Object}
-     */
-    get params() {
-        const { params, query } = this._unresolve();
-
-        return { ...params, ...query };
-    }
-
-    /**
-     * Check whether the given route exists.
-     *
-     * @param {String} name
-     * @return {Boolean}
-     */
-    has(name) {
-        return Object.keys(this._config.routes).includes(name);
-    }
-
-    /**
-     * Parse Laravel-style route parameters of any type into a normalized object.
-     *
-     * @example
-     * // with route parameter names 'event' and 'venue'
-     * _parse(1); // { event: 1 }
-     * _parse({ event: 2, venue: 3 }); // { event: 2, venue: 3 }
-     * _parse(['Taylor', 'Matt']); // { event: 'Taylor', venue: 'Matt' }
-     * _parse([4, { uuid: 56789, name: 'Grand Canyon' }]); // { event: 4, venue: 56789 }
-     *
-     * @param {(String|Number|Array|Object)} params - Route parameters.
-     * @param {Route} route - Route instance.
-     * @return {Object} Normalized complete route parameters.
-     */
-    _parse(params = {}, route = this._route) {
-        params ??= {}
-
-        // If `params` is a string or integer, wrap it in an array
-        params = ['string', 'number'].includes(typeof params) ? [params] : params;
-
-        // Separate segments with and without defaults, and fill in the default values
-        const segments = route.parameterSegments.filter(({ name }) => !this._config.defaults[name]);
-
-        if (Array.isArray(params)) {
-            // If the parameters are an array they have to be in order, so we can transform them into
-            // an object by keying them with the template segment names in the order they appear
-            params = params.reduce((result, current, i) => segments[i]
-                ? ({ ...result, [segments[i].name]: current })
-                : typeof current === 'object'
-                    ? ({ ...result, ...current })
-                    : ({ ...result, [current]: '' }), {});
-        } else if (
-            segments.length === 1
-            && !params[segments[0].name]
-            && (params.hasOwnProperty(Object.values(route.bindings)[0]) || params.hasOwnProperty('id'))
-        ) {
-            // If there is only one template segment and `params` is an object, that object is
-            // ambiguous—it could contain the parameter key and value, or it could be an object
-            // representing just the value (e.g. a model); we can inspect it to find out, and
-            // if it's just the parameter value, we can wrap it in an object with its key
-            params = { [segments[0].name]: params };
-        }
-
-        return {
-            ...this._defaults(route),
-            ...this._substituteBindings(params, route),
-        };
-    }
-
-    /**
-     * Populate default parameters for the given route.
-     *
-     * @example
-     * // with default parameters { locale: 'en', country: 'US' } and 'posts.show' route '{locale}/posts/{post}'
-     * defaults(...); // { locale: 'en' }
-     *
-     * @param {Route} route
-     * @return {Object} Default route parameters.
-     */
-    _defaults(route) {
-        return route.parameterSegments.filter(({ name }) => this._config.defaults[name])
-            .reduce((result, { name }, i) => ({ ...result, [name]: this._config.defaults[name] }), {});
-    }
-
-    /**
-     * Substitute Laravel route model bindings in the given parameters.
-     *
-     * @example
-     * _substituteBindings({ post: { id: 4, slug: 'hello-world', title: 'Hello, world!' } }, { bindings: { post: 'slug' } }); // { post: 'hello-world' }
-     *
-     * @param {Object} params - Route parameters.
-     * @param {Object} route - Route definition.
-     * @return {Object} Normalized route parameters.
-     */
-    _substituteBindings(params, { bindings, parameterSegments }) {
-        return Object.entries(params).reduce((result, [key, value]) => {
-            // If the value isn't an object, or if the key isn't a named route parameter,
-            // there's nothing to substitute so we return it as-is
-            if (!value || typeof value !== 'object' || Array.isArray(value) || !parameterSegments.some(({ name }) => name === key)) {
-                return { ...result, [key]: value };
-            }
-
-            if (!value.hasOwnProperty(bindings[key])) {
-                if (value.hasOwnProperty('id')) {
-                    // As a fallback, we still accept an 'id' key not explicitly registered as a binding
-                    bindings[key] = 'id';
-                } else {
-                    throw new Error(`Ziggy error: object passed as '${key}' parameter is missing route model binding key '${bindings[key]}'.`)
-                }
-            }
-
-            return { ...result, [key]: value[bindings[key]] };
-        }, {});
-    }
-
-    valueOf() {
-        return this.toString();
-    }
-
-    /**
-     * @deprecated since v1.0, use `has()` instead.
-     */
-    check(name) {
-        return this.has(name);
-    }
-}

package/src/js/index.js

@@ -1,7 +0,0 @@
-import Router from './Router';
-
-export default function route(name, params, absolute, config) {
-    const router = new Router(name, params, absolute, config);
-
-    return name ? router.toString() : router;
-}

package/src/js/react.js

@@ -1,9 +0,0 @@
-import route from './index.js';
-
-export function useRoute(defaultConfig) {
-    if (!defaultConfig && !globalThis.Ziggy && typeof Ziggy === 'undefined') {
-        throw new Error('Ziggy error: missing configuration. Ensure that a `Ziggy` variable is defined globally or pass a config object into `useRoute()`.');
-    }
-
-    return (name, params, absolute, config = defaultConfig) => route(name, params, absolute, config);
-};

package/src/js/vue.js

@@ -1,17 +0,0 @@
-import route from './index.js';
-
-export const ZiggyVue = {
-    install(app, options) {
-        const r = (name, params, absolute, config = options) => route(name, params, absolute, config);
-
-        app.mixin({
-            methods: {
-                route: r,
-            },
-        });
-
-        if (parseInt(app.version) > 2) {
-            app.provide('route', r);
-        }
-    },
-};