@phragon/path-to-pattern v0.1.1

@phragon/path-to-pattern

The project is under construction, the description will be later

❯ Install

$ npm install --save @phragon/plugin-orm

Example:

pathToPattern("/:id"); // eq. "/all" -> {id: "all"}
pathToPattern("/:language|in(ru,en,fr)/*"); // eq. "/ru/any/123" -> {language: "ru", "*": ["any", "123"]}
pathToPattern("/s-1/s-2/:name?"); // eq. "/s-1/s-2" -> {} or "/s-1/s-2/abc" -> {name: "abc"}

// escape

// spetial chars :,?|{}()

// :keyName
// :keyName? - optional
// {prefix:keyNameInGroup\suffix}
// :keyName|modifier(arg1,arg2,arg3)
pathToPattern("/segment\:id/more/:id"); // eq. "/segment:id/more/abc" -> {id: "abc"}

// group

pathToPattern("/{prefix:id|d}{-:category?|d}"); // eq. "/1" -> {id: 1} or "/1-3" -> {id: 1, category: 3}

// modifiers

pathToPattern("/:id|d"); // only number from 0 to infinity
pathToPattern("/:id|r(1,20)"); // number from 1 to 20
pathToPattern("/:id|dIn(1,2,3,4)"); // number only 1,2,3,4
pathToPattern("/:id|n(5,7,-)"); // number with length from 5 to 7 with symbol - exm. "/01234" "/123-23-23"

Functions

declare function addModifier(name: string, options: AddModifierOptions): void;
declare function compilePath<R = any>(path: string): PatternInterface<R>;
declare function matchPath(path: string | PatternInterface, pathname: string, options?: MatchOptions): any;
declare function matchToPath<R = any>(path: string | PatternInterface, options?: ReplaceOptions<R>): string;
declare function pathToPattern<R = any>(path: string, options?: PathToPatternOptions): PatternInterface<R>;

Modifiers

The parameter can have a modifier. Added after specifying the name through the sign |

Variant

/path/:id|d         ->  { id: number }
/path/:id?|d        ->  { id?: number }
/:lang|in(ru,en)/*  ->  { lang: "ru" | "en", "*": string[] }

The n modifier

String consisting of numbers

RegExp: [0-9]+

Variant

:name|n
:name|n(length: number)
:name|n(min: number, max: number)
:name|n(min: number, max: number, with_chars: string)

The d modifier

Positive number from zero or more

RegExp: 0|[1-9][0-9]*

The l modifier

Lower case

RegExp: [a-z]+

The u modifier

Upper case

RegExp: [A-Z]+

The w modifier

Letters, numbers, sign _ and -

RegExp: [a-zA-Z0-9_\-]+

The wl modifier

Lower case, numbers, sign _ and -

RegExp: [a-z0-9_\-]+

The wu modifier

Upper case, numbers, sign _ and -

RegExp: [A-Z0-9_\-]+

The in & dIn modifier

List of choices

Variant

:name|in(... args: string[])
:name|dIn(... args: number[])

RegExp: .+? & 0|[1-9][0-9]*

The not & dNot modifier

All choices except the specified list

Variant

:name|not(... args: string[])
:name|dNot(... args: number[])

RegExp: .+? & 0|[1-9][0-9]*

The uuid modifier

UUID string, lowercase only or UPPERCASE only

RegExp: [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}

The date modifier

Date string

RegExp: .+?

Variant

:name|date(format?: string, timezone_offset?: string)
:name|date
:name|date(c)
:name|date(U)

The reg modifier

Regular expression. Returns a string or math/array result if the regular expression includes groups

Variant

:reg|not(... args: string[])

RegExp: .+?