ziggy-js 1.7.2 → 1.8.1

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);
-        }
-    },
-};