path-to-regexp 6.2.2 → 7.1.0

package/dist/index.d.ts

@@ -1,50 +1,97 @@
+/**
+ * Encode a string into another string.
+ */
+export type Encode = (value: string) => string;
+/**
+ * Decode a string into another string.
+ */
+export type Decode = (value: string) => string;
 export interface ParseOptions {
     /**
-     * Set the default delimiter for repeat parameters. (default: `'/'`)
+     * The default delimiter for segments. (default: `'/'`)
      */
     delimiter?: string;
     /**
-     * List of characters to automatically consider prefixes when parsing.
+     * A function for encoding input strings.
      */
-    prefixes?: string;
+    encodePath?: Encode;
 }
-/**
- * Parse a string for the raw tokens.
- */
-export declare function parse(str: string, options?: ParseOptions): Token[];
-export interface TokensToFunctionOptions {
+export interface PathToRegexpOptions extends ParseOptions {
     /**
-     * When `true` the regexp will be case sensitive. (default: `false`)
+     * Regexp will be case sensitive. (default: `false`)
      */
     sensitive?: boolean;
     /**
-     * Function for encoding input strings for output.
+     * Allow the delimiter to be arbitrarily repeated. (default: `true`)
      */
-    encode?: (value: string, token: Key) => string;
+    loose?: boolean;
     /**
-     * When `false` the function can produce an invalid (unmatched) path. (default: `true`)
+     * Verify patterns are valid and safe to use. (default: `false`)
+     */
+    strict?: boolean;
+    /**
+     * Match from the beginning of the string. (default: `true`)
+     */
+    start?: boolean;
+    /**
+     * Match to the end of the string. (default: `true`)
+     */
+    end?: boolean;
+    /**
+     * Allow optional trailing delimiter to match. (default: `true`)
+     */
+    trailing?: boolean;
+}
+export interface MatchOptions extends PathToRegexpOptions {
+    /**
+     * Function for decoding strings for params, or `false` to disable entirely. (default: `decodeURIComponent`)
+     */
+    decode?: Decode | false;
+}
+export interface CompileOptions extends ParseOptions {
+    /**
+     * Regexp will be case sensitive. (default: `false`)
+     */
+    sensitive?: boolean;
+    /**
+     * Allow the delimiter to be arbitrarily repeated. (default: `true`)
+     */
+    loose?: boolean;
+    /**
+     * Verify patterns are valid and safe to use. (default: `false`)
+     */
+    strict?: boolean;
+    /**
+     * Verifies the function is producing a valid path. (default: `true`)
      */
     validate?: boolean;
+    /**
+     * Function for encoding input strings for output into the path, or `false` to disable entirely. (default: `encodeURIComponent`)
+     */
+    encode?: Encode | false;
 }
 /**
- * Compile a string to a template function for the path.
+ * Tokenized path instance. Can we passed around instead of string.
  */
-export declare function compile<P extends object = object>(str: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
-export type PathFunction<P extends object = object> = (data?: P) => string;
+export declare class TokenData {
+    readonly tokens: Token[];
+    readonly delimiter: string;
+    constructor(tokens: Token[], delimiter: string);
+}
 /**
- * Expose a method for transforming tokens into the path function.
+ * Parse a string for the raw tokens.
  */
-export declare function tokensToFunction<P extends object = object>(tokens: Token[], options?: TokensToFunctionOptions): PathFunction<P>;
-export interface RegexpToFunctionOptions {
-    /**
-     * Function for decoding strings for params.
-     */
-    decode?: (value: string, token: Key) => string;
-}
+export declare function parse(str: string, options?: ParseOptions): TokenData;
+/**
+ * Compile a string to a template function for the path.
+ */
+export declare function compile<P extends ParamData = ParamData>(path: Path, options?: CompileOptions): PathFunction<P>;
+export type ParamData = Partial<Record<string, string | string[]>>;
+export type PathFunction<P extends ParamData> = (data?: P) => string;
 /**
  * A match result contains data about the path match.
  */
-export interface MatchResult<P extends object = object> {
+export interface MatchResult<P extends ParamData> {
     path: string;
     index: number;
     params: P;
@@ -52,71 +99,34 @@ export interface MatchResult<P extends object = object> {
 /**
  * A match is either `false` (no match) or a match result.
  */
-export type Match<P extends object = object> = false | MatchResult<P>;
+export type Match<P extends ParamData> = false | MatchResult<P>;
 /**
  * The match function takes a string and returns whether it matched the path.
  */
-export type MatchFunction<P extends object = object> = (path: string) => Match<P>;
+export type MatchFunction<P extends ParamData> = (path: string) => Match<P>;
 /**
  * Create path match function from `path-to-regexp` spec.
  */
-export declare function match<P extends object = object>(str: Path, options?: ParseOptions & TokensToRegexpOptions & RegexpToFunctionOptions): MatchFunction<P>;
+export declare function match<P extends ParamData>(path: Path, options?: MatchOptions): MatchFunction<P>;
 /**
- * Create a path match function from `path-to-regexp` output.
- */
-export declare function regexpToFunction<P extends object = object>(re: RegExp, keys: Key[], options?: RegexpToFunctionOptions): MatchFunction<P>;
-/**
- * Metadata about a key.
+ * A key is a capture group in the regex.
  */
 export interface Key {
-    name: string | number;
-    prefix: string;
-    suffix: string;
-    pattern: string;
-    modifier: string;
+    name: string;
+    prefix?: string;
+    suffix?: string;
+    pattern?: string;
+    modifier?: string;
+    separator?: string;
 }
 /**
  * A token is a string (nothing special) or key metadata (capture group).
  */
 export type Token = string | Key;
-export interface TokensToRegexpOptions {
-    /**
-     * When `true` the regexp will be case sensitive. (default: `false`)
-     */
-    sensitive?: boolean;
-    /**
-     * When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`)
-     */
-    strict?: boolean;
-    /**
-     * When `true` the regexp will match to the end of the string. (default: `true`)
-     */
-    end?: boolean;
-    /**
-     * When `true` the regexp will match from the beginning of the string. (default: `true`)
-     */
-    start?: boolean;
-    /**
-     * Sets the final character for non-ending optimistic matches. (default: `/`)
-     */
-    delimiter?: string;
-    /**
-     * List of characters that can also be "end" characters.
-     */
-    endsWith?: string;
-    /**
-     * Encode path tokens for use in the `RegExp`.
-     */
-    encode?: (value: string) => string;
-}
-/**
- * Expose a function for taking tokens and returning a RegExp.
- */
-export declare function tokensToRegexp(tokens: Token[], keys?: Key[], options?: TokensToRegexpOptions): RegExp;
 /**
- * Supported `path-to-regexp` input types.
+ * Repeated and simple input types.
  */
-export type Path = string | RegExp | Array<string | RegExp>;
+export type Path = string | TokenData;
 /**
  * Normalize the given path string, returning a regular expression.
  *
@@ -124,4 +134,6 @@ export type Path = string | RegExp | Array<string | RegExp>;
  * placeholder key descriptions. For example, using `/user/:id`, `keys` will
  * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
  */
-export declare function pathToRegexp(path: Path, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions): RegExp;
+export declare function pathToRegexp(path: Path, options?: PathToRegexpOptions): RegExp & {
+    keys: Key[];
+};