Logo for jsDocs.io

path-to-regexp

  • Version 9.0.0
  • Published
  • 60.5 kB
  • No dependencies
  • MIT license

Install

npm i path-to-regexp
yarn add path-to-regexp
pnpm add path-to-regexp

Overview

Express style path to RegExp utility

Index

Functions

Classes

Interfaces

Type Aliases

Functions

function compile

compile: <
    P extends Partial<Record<string, string | string[]>> = Partial<
        Record<string, string | string[]>
    >
>(
    path: Path,
    options?: CompileOptions & ParseOptions
) => (params?: P) => string;

  • Compile a string to a template function for the path.

function match

match: <P extends Partial<Record<string, string | string[]>>>(
    path: Path | Path[],
    options?: MatchOptions & ParseOptions
) => MatchFunction<P>;

  • Transform a path into a match function.

function parse

parse: (str: string, options?: ParseOptions) => TokenData;

  • Parse a string for the raw tokens.

function pathToRegexp

pathToRegexp: (
    path: Path | Path[],
    options?: PathToRegexpOptions & ParseOptions
) => { regexp: RegExp; keys: Key[] };

  • Transform a path into a regular expression and capture keys.

function stringify

stringify: (data: TokenData) => string;

  • Stringify token data into a path string.

Classes

class PathError

class PathError extends TypeError {}

  • ParseError is thrown when there is an error processing the path.

constructor

constructor(message: string, originalPath: string);

    property originalPath

    readonly originalPath: string;

      Interfaces

      interface CompileOptions

      interface CompileOptions {}

        property delimiter

        delimiter?: string;

        • The default delimiter for segments. (default: '/')

        property encode

        encode?: Encode | false;

        • Function for encoding input strings for output into the path, or false to disable entirely. (default: encodeURIComponent)

        interface Group

        interface Group {}

        • A set of possible tokens to expand when matching.

        property tokens

        tokens: readonly Token[];

          property type

          type: 'group';

            interface MatchOptions

            interface MatchOptions extends PathToRegexpOptions {}

              property decode

              decode?: Decode | false;

              • Function for decoding strings for params, or false to disable entirely. (default: decodeURIComponent)

              interface MatchResult

              interface MatchResult<P extends ParamData> {}

              • A match result contains data about the path match.

              property params

              params: P;

                property path

                path: string;

                  interface Parameter

                  interface Parameter {}

                  • A parameter designed to match arbitrary text within a segment.

                  property name

                  name: string;

                    property type

                    type: 'param';

                      interface ParseOptions

                      interface ParseOptions {}

                        property encodePath

                        encodePath?: Encode;

                        • A function for encoding input strings.

                        interface PathToRegexpOptions

                        interface PathToRegexpOptions {}

                          property delimiter

                          delimiter?: string;

                          • The default delimiter for segments. (default: '/')

                          property end

                          end?: boolean;

                          • Matches the path completely without trailing characters. (default: true)

                          property sensitive

                          sensitive?: boolean;

                          • Match will be case sensitive. (default: false)

                          property trailing

                          trailing?: boolean;

                          • Allows optional trailing delimiter to match. (default: true)

                          interface Text

                          interface Text {}

                          • Plain text.

                          property type

                          type: 'text';

                            property value

                            value: string;

                              interface TokenData

                              interface TokenData {}

                              • Tokenized path instance.

                              property originalPath

                              originalPath?: string;

                                property tokens

                                tokens: readonly Token[];

                                  interface Wildcard

                                  interface Wildcard {}

                                  • A wildcard parameter designed to match multiple segments.

                                  property name

                                  name: string;

                                    property type

                                    type: 'wildcard';

                                      Type Aliases

                                      type Decode

                                      type Decode = (value: string) => string;

                                      • Decode a string into another string.

                                      type Encode

                                      type Encode = (value: string) => string;

                                      • Encode a string into another string.

                                      type Key

                                      type Key = Parameter | Wildcard;

                                      • Tokens that corresponds with a regexp capture.

                                      type Match

                                      type Match<P extends ParamData> = false | MatchResult<P>;

                                      • A match is either false (no match) or a match result.

                                      type MatchFunction

                                      type MatchFunction<P extends ParamData> = (path: string) => Match<P>;

                                      • The match function takes a string and returns whether it matched the path.

                                      type ParamData

                                      type ParamData = Partial<Record<string, string | string[]>>;

                                        type Path

                                        type Path = string | TokenData;

                                        • Supported path inputs.

                                        type PathFunction

                                        type PathFunction<P extends ParamData> = (data?: P) => string;

                                          type Token

                                          type Token = Text | Parameter | Wildcard | Group;

                                          • A sequence of path match characters.

                                          Package Files (1)

                                          Dependencies (0)

                                          No dependencies.

                                          Dev Dependencies (9)

                                          Peer Dependencies (0)

                                          No peer dependencies.

                                          Badge

                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/path-to-regexp.

                                          • Markdown
                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/path-to-regexp)
                                          • HTML
                                            <a href="https://www.jsdocs.io/package/path-to-regexp"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>