resig.js/build/module/router/route.js

Universal reactive signal library with complete platform features: signals, animations, CRDTs, scheduling, DOM integration. Works identically across React, SolidJS, Svelte, Vue, and Qwik.

/**
 * Route Implementation - Functor Laws
 * Core route primitives and combinators
 */
import { Some, None } from './types';
/**
 * Identity function for functor law verification
 */
export const id = (a) => a;
/**
 * Function composition for functor law verification
 */
export const compose = (f, g) => (a) => f(g(a));
/**
 * Creates a route functor that follows categorical laws
 */
const createRoute = (path, parser, generator, matcher) => {
    const routeInstance = {
        path,
        params: {}, // Will be set during parsing
        map: (f) => {
            return createRoute(path, (inputPath) => {
                const parsed = parser(inputPath);
                return parsed ? f(parsed) : null;
            }, (params) => {
                // For mapped routes, we need to reverse the transformation
                // This is complex for arbitrary functions, so we'll use the original generator
                // In practice, this would require bijective functions or additional type info
                return generator(params); // Type assertion needed here
            }, matcher);
        },
        matches: matcher,
        parse: parser,
        generate: generator
    };
    return routeInstance;
};
/**
 * Literal route - matches exact path
 */
export const literal = (path) => {
    return createRoute(path, (inputPath) => (inputPath === path ? {} : null), () => path, (inputPath) => inputPath === path);
};
/**
 * Parameter route - extracts path parameters
 */
export const param = (template) => {
    const paramRegex = /:([^/]+)/g;
    const paramNames = [];
    let match;
    while ((match = paramRegex.exec(template)) !== null) {
        paramNames.push(match[1]);
    }
    const pathRegex = new RegExp('^' + template.replace(/:([^/]+)/g, '([^/]+)') + '$');
    return createRoute(template, (inputPath) => {
        const match = pathRegex.exec(inputPath);
        if (!match)
            return null;
        const params = {};
        paramNames.forEach((name, index) => {
            params[name] = match[index + 1];
        });
        return params;
    }, (params) => {
        let result = template;
        Object.entries(params).forEach(([key, value]) => {
            result = result.replace(`:${key}`, String(value));
        });
        return result;
    }, (inputPath) => pathRegex.test(inputPath));
};
/**
 * Query route - extracts query parameters
 */
export const query = (basePath) => {
    return createRoute(basePath, (inputPath) => {
        const [path, queryString] = inputPath.split('?');
        if (path !== basePath)
            return null;
        const params = {};
        if (queryString) {
            const searchParams = new URLSearchParams(queryString);
            for (const [key, value] of searchParams.entries()) {
                params[key] = value;
            }
        }
        return params;
    }, (params) => {
        const queryString = Object.entries(params)
            .filter(([_, value]) => value !== undefined)
            .map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`)
            .join('&');
        return queryString ? `${basePath}?${queryString}` : basePath;
    }, (inputPath) => {
        const [path] = inputPath.split('?');
        return path === basePath;
    });
};
/**
 * Wildcard route - catches all paths
 */
export const wildcard = (pattern) => {
    const isGlobal = pattern === '*';
    const prefix = isGlobal ? '' : pattern.replace('*', '');
    return createRoute(pattern, (inputPath) => {
        if (isGlobal || inputPath.startsWith(prefix)) {
            return { path: inputPath };
        }
        return null;
    }, ({ path }) => path, (inputPath) => {
        return isGlobal || inputPath.startsWith(prefix);
    });
};
/**
 * Route Combinators - Algebraic Operations
 */
/**
 * Sequence combinator - combines routes in sequence
 */
export const sequence = (routeA, routeB) => {
    const combinedPath = `${routeA.path}${routeB.path}`;
    return createRoute(combinedPath, (inputPath) => {
        // Try to match the first part
        const aResult = routeA.parse(inputPath);
        if (!aResult)
            return null;
        // Extract remaining path for second route
        const remainingPath = inputPath.substring(routeA.path.length);
        const bResult = routeB.parse(remainingPath);
        if (!bResult)
            return null;
        return { ...aResult, ...bResult };
    }, (params) => {
        return routeA.generate(params) + routeB.generate(params);
    }, (inputPath) => {
        return routeA.matches(inputPath) && routeB.matches(inputPath.substring(routeA.path.length));
    });
};
/**
 * Choice combinator - tries routes in order
 */
export const choice = (routes) => {
    if (routes.length === 0) {
        throw new Error('Choice combinator requires at least one route');
    }
    const combinedPath = routes.map(r => r.path).join(' | ');
    return createRoute(combinedPath, (inputPath) => {
        for (const route of routes) {
            const result = route.parse(inputPath);
            if (result)
                return result;
        }
        return null;
    }, (params) => {
        // For generation, we need to know which route to use
        // This is a limitation of the choice combinator
        // In practice, we'd need additional type information
        return routes[0].generate(params);
    }, (inputPath) => {
        return routes.some(route => route.matches(inputPath));
    });
};
/**
 * Optional combinator - makes route optional
 */
export const optional = (route) => {
    return createRoute(`${route.path}?`, (inputPath) => {
        const result = route.parse(inputPath);
        return result !== null ? result : null;
    }, (params) => {
        return params ? route.generate(params) : '';
    }, (inputPath) => {
        return inputPath === '' || route.matches(inputPath);
    });
};
/**
 * Nested combinator - creates nested routes
 */
export const nested = (parent, _child) => {
    return parent.map(parentParams => ({
        ...parentParams,
        child: {} // Will be filled by child route
    }));
};
/**
 * Route matching utility
 */
export const matchRoute = (routes, path) => {
    for (const route of routes) {
        if (route.matches(path)) {
            return Some(route);
        }
    }
    return None;
};
/**
 * Type-safe route builder
 */
export const route = (template) => {
    if (template.includes(':')) {
        return param(template);
    }
    else if (template.includes('?')) {
        return query(template.split('?')[0]);
    }
    else if (template.includes('*')) {
        return wildcard(template);
    }
    else {
        return literal(template);
    }
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route.js","sourceRoot":"","sources":["../../../src/router/route.ts"],"names":[],"mappings":"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"}