Initial code test
This commit is contained in:
chris committed
commit
d4fae15f5c
1696 files changed
+271223
No files matched your search
+147
@@ -0,0 +1,147 @@
|
||||
/**
|
||||
* 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 {
|
||||
/**
|
||||
* A function for encoding input strings.
|
||||
*/
|
||||
encodePath?: Encode;
|
||||
}
|
||||
export interface PathToRegexpOptions {
|
||||
/**
|
||||
* Matches the path completely without trailing characters. (default: `true`)
|
||||
*/
|
||||
end?: boolean;
|
||||
/**
|
||||
* Allows optional trailing delimiter to match. (default: `true`)
|
||||
*/
|
||||
trailing?: boolean;
|
||||
/**
|
||||
* Match will be case sensitive. (default: `false`)
|
||||
*/
|
||||
sensitive?: boolean;
|
||||
/**
|
||||
* The default delimiter for segments. (default: `'/'`)
|
||||
*/
|
||||
delimiter?: string;
|
||||
}
|
||||
export interface MatchOptions extends PathToRegexpOptions {
|
||||
/**
|
||||
* Function for decoding strings for params, or `false` to disable entirely. (default: `decodeURIComponent`)
|
||||
*/
|
||||
decode?: Decode | false;
|
||||
}
|
||||
export interface CompileOptions {
|
||||
/**
|
||||
* Function for encoding input strings for output into the path, or `false` to disable entirely. (default: `encodeURIComponent`)
|
||||
*/
|
||||
encode?: Encode | false;
|
||||
/**
|
||||
* The default delimiter for segments. (default: `'/'`)
|
||||
*/
|
||||
delimiter?: string;
|
||||
}
|
||||
/**
|
||||
* Plain text.
|
||||
*/
|
||||
export interface Text {
|
||||
type: "text";
|
||||
value: string;
|
||||
}
|
||||
/**
|
||||
* A parameter designed to match arbitrary text within a segment.
|
||||
*/
|
||||
export interface Parameter {
|
||||
type: "param";
|
||||
name: string;
|
||||
}
|
||||
/**
|
||||
* A wildcard parameter designed to match multiple segments.
|
||||
*/
|
||||
export interface Wildcard {
|
||||
type: "wildcard";
|
||||
name: string;
|
||||
}
|
||||
/**
|
||||
* A set of possible tokens to expand when matching.
|
||||
*/
|
||||
export interface Group {
|
||||
type: "group";
|
||||
tokens: Token[];
|
||||
}
|
||||
/**
|
||||
* A token that corresponds with a regexp capture.
|
||||
*/
|
||||
export type Key = Parameter | Wildcard;
|
||||
/**
|
||||
* A sequence of `path-to-regexp` keys that match capturing groups.
|
||||
*/
|
||||
export type Keys = Array<Key>;
|
||||
/**
|
||||
* A sequence of path match characters.
|
||||
*/
|
||||
export type Token = Text | Parameter | Wildcard | Group;
|
||||
/**
|
||||
* Tokenized path instance.
|
||||
*/
|
||||
export declare class TokenData {
|
||||
readonly tokens: Token[];
|
||||
readonly originalPath?: string | undefined;
|
||||
constructor(tokens: Token[], originalPath?: string | undefined);
|
||||
}
|
||||
/**
|
||||
* ParseError is thrown when there is an error processing the path.
|
||||
*/
|
||||
export declare class PathError extends TypeError {
|
||||
readonly originalPath: string | undefined;
|
||||
constructor(message: string, originalPath: string | undefined);
|
||||
}
|
||||
/**
|
||||
* Parse a string for the raw tokens.
|
||||
*/
|
||||
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 & ParseOptions): (params?: P) => string;
|
||||
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 ParamData> {
|
||||
path: string;
|
||||
params: P;
|
||||
}
|
||||
/**
|
||||
* A match is either `false` (no match) or a match result.
|
||||
*/
|
||||
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 ParamData> = (path: string) => Match<P>;
|
||||
/**
|
||||
* Supported path types.
|
||||
*/
|
||||
export type Path = string | TokenData;
|
||||
/**
|
||||
* Transform a path into a match function.
|
||||
*/
|
||||
export declare function match<P extends ParamData>(path: Path | Path[], options?: MatchOptions & ParseOptions): MatchFunction<P>;
|
||||
/**
|
||||
* Transform a path into a regular expression and capture keys.
|
||||
*/
|
||||
export declare function pathToRegexp(path: Path | Path[], options?: PathToRegexpOptions & ParseOptions): {
|
||||
regexp: RegExp;
|
||||
keys: Keys;
|
||||
};
|
||||
/**
|
||||
* Stringify token data into a path string.
|
||||
*/
|
||||
export declare function stringify(data: TokenData): string;
|
||||
+431
@@ -0,0 +1,431 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.PathError = exports.TokenData = void 0;
|
||||
exports.parse = parse;
|
||||
exports.compile = compile;
|
||||
exports.match = match;
|
||||
exports.pathToRegexp = pathToRegexp;
|
||||
exports.stringify = stringify;
|
||||
const DEFAULT_DELIMITER = "/";
|
||||
const NOOP_VALUE = (value) => value;
|
||||
const ID_START = /^[$_\p{ID_Start}]$/u;
|
||||
const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
|
||||
const ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
|
||||
/**
|
||||
* Escape text for stringify to path.
|
||||
*/
|
||||
function escapeText(str) {
|
||||
return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
|
||||
}
|
||||
/**
|
||||
* Escape a regular expression string.
|
||||
*/
|
||||
function escape(str) {
|
||||
return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
|
||||
}
|
||||
/**
|
||||
* Tokenized path instance.
|
||||
*/
|
||||
class TokenData {
|
||||
constructor(tokens, originalPath) {
|
||||
this.tokens = tokens;
|
||||
this.originalPath = originalPath;
|
||||
}
|
||||
}
|
||||
exports.TokenData = TokenData;
|
||||
/**
|
||||
* ParseError is thrown when there is an error processing the path.
|
||||
*/
|
||||
class PathError extends TypeError {
|
||||
constructor(message, originalPath) {
|
||||
let text = message;
|
||||
if (originalPath)
|
||||
text += `: ${originalPath}`;
|
||||
text += `; visit https://git.new/pathToRegexpError for info`;
|
||||
super(text);
|
||||
this.originalPath = originalPath;
|
||||
}
|
||||
}
|
||||
exports.PathError = PathError;
|
||||
/**
|
||||
* Parse a string for the raw tokens.
|
||||
*/
|
||||
function parse(str, options = {}) {
|
||||
const { encodePath = NOOP_VALUE } = options;
|
||||
const chars = [...str];
|
||||
let index = 0;
|
||||
function consumeUntil(end) {
|
||||
const output = [];
|
||||
let path = "";
|
||||
function writePath() {
|
||||
if (!path)
|
||||
return;
|
||||
output.push({
|
||||
type: "text",
|
||||
value: encodePath(path),
|
||||
});
|
||||
path = "";
|
||||
}
|
||||
while (index < chars.length) {
|
||||
const value = chars[index++];
|
||||
if (value === end) {
|
||||
writePath();
|
||||
return output;
|
||||
}
|
||||
if (value === "\\") {
|
||||
if (index === chars.length) {
|
||||
throw new PathError(`Unexpected end after \\ at index ${index}`, str);
|
||||
}
|
||||
path += chars[index++];
|
||||
continue;
|
||||
}
|
||||
if (value === ":" || value === "*") {
|
||||
const type = value === ":" ? "param" : "wildcard";
|
||||
let name = "";
|
||||
if (ID_START.test(chars[index])) {
|
||||
do {
|
||||
name += chars[index++];
|
||||
} while (ID_CONTINUE.test(chars[index]));
|
||||
}
|
||||
else if (chars[index] === '"') {
|
||||
let quoteStart = index;
|
||||
while (index < chars.length) {
|
||||
if (chars[++index] === '"') {
|
||||
index++;
|
||||
quoteStart = 0;
|
||||
break;
|
||||
}
|
||||
// Increment over escape characters.
|
||||
if (chars[index] === "\\")
|
||||
index++;
|
||||
name += chars[index];
|
||||
}
|
||||
if (quoteStart) {
|
||||
throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
|
||||
}
|
||||
}
|
||||
if (!name) {
|
||||
throw new PathError(`Missing parameter name at index ${index}`, str);
|
||||
}
|
||||
writePath();
|
||||
output.push({ type, name });
|
||||
continue;
|
||||
}
|
||||
if (value === "{") {
|
||||
writePath();
|
||||
output.push({
|
||||
type: "group",
|
||||
tokens: consumeUntil("}"),
|
||||
});
|
||||
continue;
|
||||
}
|
||||
if (value === "}" ||
|
||||
value === "(" ||
|
||||
value === ")" ||
|
||||
value === "[" ||
|
||||
value === "]" ||
|
||||
value === "+" ||
|
||||
value === "?" ||
|
||||
value === "!") {
|
||||
throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
|
||||
}
|
||||
path += value;
|
||||
}
|
||||
if (end) {
|
||||
throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
|
||||
}
|
||||
writePath();
|
||||
return output;
|
||||
}
|
||||
return new TokenData(consumeUntil(""), str);
|
||||
}
|
||||
/**
|
||||
* Compile a string to a template function for the path.
|
||||
*/
|
||||
function compile(path, options = {}) {
|
||||
const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
|
||||
const data = typeof path === "object" ? path : parse(path, options);
|
||||
const fn = tokensToFunction(data.tokens, delimiter, encode);
|
||||
return function path(params = {}) {
|
||||
const missing = [];
|
||||
const path = fn(params, missing);
|
||||
if (missing.length) {
|
||||
throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
|
||||
}
|
||||
return path;
|
||||
};
|
||||
}
|
||||
function tokensToFunction(tokens, delimiter, encode) {
|
||||
const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
|
||||
return (data, missing) => {
|
||||
let result = "";
|
||||
for (const encoder of encoders) {
|
||||
result += encoder(data, missing);
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Convert a single token into a path building function.
|
||||
*/
|
||||
function tokenToFunction(token, delimiter, encode) {
|
||||
if (token.type === "text")
|
||||
return () => token.value;
|
||||
if (token.type === "group") {
|
||||
const fn = tokensToFunction(token.tokens, delimiter, encode);
|
||||
return (data, missing) => {
|
||||
const len = missing.length;
|
||||
const value = fn(data, missing);
|
||||
if (missing.length === len)
|
||||
return value;
|
||||
missing.length = len; // Reset optional group.
|
||||
return "";
|
||||
};
|
||||
}
|
||||
const encodeValue = encode || NOOP_VALUE;
|
||||
if (token.type === "wildcard" && encode !== false) {
|
||||
return (data, missing) => {
|
||||
const value = data[token.name];
|
||||
if (value == null) {
|
||||
missing.push(token.name);
|
||||
return "";
|
||||
}
|
||||
if (!Array.isArray(value) || value.length === 0) {
|
||||
throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
|
||||
}
|
||||
let result = "";
|
||||
for (let i = 0; i < value.length; i++) {
|
||||
if (typeof value[i] !== "string") {
|
||||
throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
|
||||
}
|
||||
if (i > 0)
|
||||
result += delimiter;
|
||||
result += encodeValue(value[i]);
|
||||
}
|
||||
return result;
|
||||
};
|
||||
}
|
||||
return (data, missing) => {
|
||||
const value = data[token.name];
|
||||
if (value == null) {
|
||||
missing.push(token.name);
|
||||
return "";
|
||||
}
|
||||
if (typeof value !== "string") {
|
||||
throw new TypeError(`Expected "${token.name}" to be a string`);
|
||||
}
|
||||
return encodeValue(value);
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Transform a path into a match function.
|
||||
*/
|
||||
function match(path, options = {}) {
|
||||
const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
|
||||
const { regexp, keys } = pathToRegexp(path, options);
|
||||
const decoders = keys.map((key) => {
|
||||
if (decode === false)
|
||||
return NOOP_VALUE;
|
||||
if (key.type === "param")
|
||||
return decode;
|
||||
return (value) => value.split(delimiter).map(decode);
|
||||
});
|
||||
return function match(input) {
|
||||
const m = regexp.exec(input);
|
||||
if (!m)
|
||||
return false;
|
||||
const path = m[0];
|
||||
const params = Object.create(null);
|
||||
for (let i = 1; i < m.length; i++) {
|
||||
if (m[i] === undefined)
|
||||
continue;
|
||||
const key = keys[i - 1];
|
||||
const decoder = decoders[i - 1];
|
||||
params[key.name] = decoder(m[i]);
|
||||
}
|
||||
return { path, params };
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Transform a path into a regular expression and capture keys.
|
||||
*/
|
||||
function pathToRegexp(path, options = {}) {
|
||||
const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;
|
||||
const keys = [];
|
||||
let source = "";
|
||||
let combinations = 0;
|
||||
function process(path) {
|
||||
if (Array.isArray(path)) {
|
||||
for (const p of path)
|
||||
process(p);
|
||||
return;
|
||||
}
|
||||
const data = typeof path === "object" ? path : parse(path, options);
|
||||
flatten(data.tokens, 0, [], (tokens) => {
|
||||
if (combinations >= 256) {
|
||||
throw new PathError("Too many path combinations", data.originalPath);
|
||||
}
|
||||
if (combinations > 0)
|
||||
source += "|";
|
||||
source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
|
||||
combinations++;
|
||||
});
|
||||
}
|
||||
process(path);
|
||||
let pattern = `^(?:${source})`;
|
||||
if (trailing)
|
||||
pattern += "(?:" + escape(delimiter) + "$)?";
|
||||
pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
|
||||
return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
|
||||
}
|
||||
/**
|
||||
* Generate a flat list of sequence tokens from the given tokens.
|
||||
*/
|
||||
function flatten(tokens, index, result, callback) {
|
||||
while (index < tokens.length) {
|
||||
const token = tokens[index++];
|
||||
if (token.type === "group") {
|
||||
const len = result.length;
|
||||
flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
|
||||
result.length = len;
|
||||
continue;
|
||||
}
|
||||
result.push(token);
|
||||
}
|
||||
callback(result);
|
||||
}
|
||||
/**
|
||||
* Transform a flat sequence of tokens into a regular expression.
|
||||
*/
|
||||
function toRegExpSource(tokens, delimiter, keys, originalPath) {
|
||||
let result = "";
|
||||
let backtrack = "";
|
||||
let wildcardBacktrack = "";
|
||||
let prevCaptureType = 0;
|
||||
let hasSegmentCapture = 0;
|
||||
let index = 0;
|
||||
function hasInSegment(index, type) {
|
||||
while (index < tokens.length) {
|
||||
const token = tokens[index++];
|
||||
if (token.type === type)
|
||||
return true;
|
||||
if (token.type === "text") {
|
||||
if (token.value.includes(delimiter))
|
||||
break;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function peekText(index) {
|
||||
let result = "";
|
||||
while (index < tokens.length) {
|
||||
const token = tokens[index++];
|
||||
if (token.type !== "text")
|
||||
break;
|
||||
result += token.value;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
while (index < tokens.length) {
|
||||
const token = tokens[index++];
|
||||
if (token.type === "text") {
|
||||
result += escape(token.value);
|
||||
backtrack += token.value;
|
||||
if (prevCaptureType === 2)
|
||||
wildcardBacktrack += token.value;
|
||||
if (token.value.includes(delimiter))
|
||||
hasSegmentCapture = 0;
|
||||
continue;
|
||||
}
|
||||
if (token.type === "param" || token.type === "wildcard") {
|
||||
if (prevCaptureType && !backtrack) {
|
||||
throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
|
||||
}
|
||||
if (token.type === "param") {
|
||||
result +=
|
||||
hasSegmentCapture & 2 // Seen wildcard in segment.
|
||||
? `(${negate(delimiter, backtrack)}+)`
|
||||
: hasInSegment(index, "wildcard") // See wildcard later in segment.
|
||||
? `(${negate(delimiter, peekText(index))}+)`
|
||||
: hasSegmentCapture & 1 // Seen parameter in segment.
|
||||
? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})`
|
||||
: `(${negate(delimiter, "")}+)`;
|
||||
hasSegmentCapture |= prevCaptureType = 1;
|
||||
}
|
||||
else {
|
||||
result +=
|
||||
hasSegmentCapture & 2 // Seen wildcard in segment.
|
||||
? `(${negate(backtrack, "")}+)`
|
||||
: wildcardBacktrack // No capture in segment, seen wildcard in path.
|
||||
? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)`
|
||||
: `([^]+)`;
|
||||
wildcardBacktrack = "";
|
||||
hasSegmentCapture |= prevCaptureType = 2;
|
||||
}
|
||||
keys.push(token);
|
||||
backtrack = "";
|
||||
continue;
|
||||
}
|
||||
throw new TypeError(`Unknown token type: ${token.type}`);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
/**
|
||||
* Block backtracking on previous text/delimiter.
|
||||
*/
|
||||
function negate(a, b) {
|
||||
if (b.length > a.length)
|
||||
return negate(b, a); // Longest string first.
|
||||
if (a === b)
|
||||
b = ""; // Cleaner regex strings, no duplication.
|
||||
if (b.length > 1)
|
||||
return `(?:(?!${escape(a)}|${escape(b)})[^])`;
|
||||
if (a.length > 1)
|
||||
return `(?:(?!${escape(a)})[^${escape(b)}])`;
|
||||
return `[^${escape(a + b)}]`;
|
||||
}
|
||||
/**
|
||||
* Stringify an array of tokens into a path string.
|
||||
*/
|
||||
function stringifyTokens(tokens, index) {
|
||||
let value = "";
|
||||
while (index < tokens.length) {
|
||||
const token = tokens[index++];
|
||||
if (token.type === "text") {
|
||||
value += escapeText(token.value);
|
||||
continue;
|
||||
}
|
||||
if (token.type === "group") {
|
||||
value += "{" + stringifyTokens(token.tokens, 0) + "}";
|
||||
continue;
|
||||
}
|
||||
if (token.type === "param") {
|
||||
value += ":" + stringifyName(token.name, tokens[index]);
|
||||
continue;
|
||||
}
|
||||
if (token.type === "wildcard") {
|
||||
value += "*" + stringifyName(token.name, tokens[index]);
|
||||
continue;
|
||||
}
|
||||
throw new TypeError(`Unknown token type: ${token.type}`);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
/**
|
||||
* Stringify token data into a path string.
|
||||
*/
|
||||
function stringify(data) {
|
||||
return stringifyTokens(data.tokens, 0);
|
||||
}
|
||||
/**
|
||||
* Stringify a parameter name, escaping when it cannot be emitted directly.
|
||||
*/
|
||||
function stringifyName(name, next) {
|
||||
if (!ID.test(name))
|
||||
return JSON.stringify(name);
|
||||
if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
|
||||
return JSON.stringify(name);
|
||||
}
|
||||
return name;
|
||||
}
|
||||
//# sourceMappingURL=index.js.map
|
||||
+1
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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 truncated
|
||||
Reference in new issue
Block a user