Logo for jsDocs.io

path-to-regexp

  • Version 8.3.0
  • Published
  • 56.3 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: 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;

        class TokenData

        class TokenData {}

        • Tokenized path instance.

        constructor

        constructor(tokens: Token[], originalPath?: string);

          property originalPath

          readonly originalPath?: string;

            property tokens

            readonly tokens: Token[];

              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: 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 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;

                                          • A token that corresponds with a regexp capture.

                                          type Keys

                                          type Keys = Array<Key>;

                                          • A sequence of path-to-regexp keys that match capturing groups.

                                          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 types.

                                            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>