@wroud/navigation/lib/pattern-matching/TriePatternMatching.d.ts

A flexible, pattern-matching navigation system for JavaScript applications with built-in routing, browser integration, and navigation state management

import type { TypedPatternMatcher, ExtractRouteParams, IPatternRouteState } from "./types.js";
import type { IRouteMatcher } from "../IRouteMatcher.js";
export interface ITriePatternMatchingOptions {
    trailingSlash?: boolean;
    base?: string;
}
/**
 * Trie-based implementation for URL pattern matching.
 * Supports static segments, parameter segments (:param), and wildcard segments (:param*).
 */
export declare class TriePatternMatching implements TypedPatternMatcher, IRouteMatcher {
    private root;
    private patterns;
    private patternToNode;
    private decodeCache;
    private encodeCache;
    private readonly MAX_CACHE_SIZE;
    private readonly options;
    constructor(options?: ITriePatternMatchingOptions);
    /**
     * Add a pattern to the trie (e.g., "/user/:id<number>")
     *
     * Parameter nodes store declared type information which
     * is later used to convert matched values.
     */
    addPattern(pattern: string): void;
    /**
     * Type guard to check if a route state matches a specific route ID
     */
    isRoute<Pattern extends string>(state: IPatternRouteState<any> | null, id: Pattern): state is IPatternRouteState<Pattern>;
    /**
     * Match a URL against the patterns in the trie
     */
    match<Pattern extends string>(url: string): IPatternRouteState<Pattern> | null;
    /**
     * Decode URL parameters based on a pattern
     */
    decode<Pattern extends string>(pattern: Pattern, url: string): ExtractRouteParams<Pattern> | null;
    /**
     * Encode parameters into a URL based on a pattern
     */
    encode<Pattern extends string>(pattern: Pattern, params: ExtractRouteParams<Pattern>): string;
    /**
     * Explicitly clear all caches
     */
    clearCaches(): void;
    /**
     * Get all registered patterns
     */
    getPatterns(): string[];
    /**
     * Get potential parent patterns for a given pattern
     */
    getPatternAncestors(pattern: string): string[];
    /**
     * Find all patterns that could be considered child patterns of the given pattern
     */
    getPatternDescendants(pattern: string): string[];
    /**
     * Collect all patterns that end in nodes below a given node
     */
    private collectDescendantPatterns;
    /**
     * Update a cache with a new result
     */
    private updateCache;
    /**
     * Ensure a cache map exists for the given key, evicting the oldest entry if needed
     */
    private ensureCacheMap;
    /**
     * Extract parameter types from a pattern by analyzing its segments
     */
    private extractParameterTypes;
    /**
     * Helper method to evict oldest cache entry if size limit is reached
     */
    private evictCacheIfNeeded;
    /**
     * Remove a pattern from the trie
     */
    removePattern(pattern: string): void;
    /**
     * Convert a URL to a route state
     */
    urlToState<Pattern extends string>(url: string): IPatternRouteState<Pattern> | null;
    /**
     * Convert a route state to a URL
     */
    stateToUrl<Pattern extends string>(state: IPatternRouteState<Pattern>): string | null;
    /**
     * Remove base path from URL if present
     */
    private removeBaseFromUrl;
    /**
     * Add base path to URL if configured
     */
    private addBaseToUrl;
}
//# sourceMappingURL=TriePatternMatching.d.ts.map