FIX: Silence route-recognizer source map errors in development mode
This commit is contained in:
Robin Ward
parent
e0c7fdc0c6
commit
9889b7277f
|
|
@ -160,7 +160,14 @@ task 'javascript:update' do
|
|||
}, {
|
||||
source: '@popperjs/core/dist/umd/popper.js.map',
|
||||
public_root: true
|
||||
}
|
||||
},
|
||||
{
|
||||
source: 'route-recognizer/dist/route-recognizer.js'
|
||||
}, {
|
||||
source: 'route-recognizer/dist/route-recognizer.js.map',
|
||||
public_root: true
|
||||
},
|
||||
|
||||
]
|
||||
|
||||
start = Time.now
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
|
@ -9,7 +9,7 @@
|
|||
//= require qunit/qunit/qunit
|
||||
//= require ember-qunit
|
||||
//= require fake_xml_http_request
|
||||
//= require route-recognizer/dist/route-recognizer
|
||||
//= require route-recognizer
|
||||
//= require pretender/pretender
|
||||
//= require locales/i18n
|
||||
//= require locales/en_US
|
||||
|
|
|
|||
|
|
@ -0,0 +1,693 @@
|
|||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
||||
typeof define === 'function' && define.amd ? define('route-recognizer', factory) :
|
||||
(global.RouteRecognizer = factory());
|
||||
}(this, (function () { 'use strict';
|
||||
|
||||
var createObject = Object.create;
|
||||
function createMap() {
|
||||
var map = createObject(null);
|
||||
map["__"] = undefined;
|
||||
delete map["__"];
|
||||
return map;
|
||||
}
|
||||
|
||||
var Target = function Target(path, matcher, delegate) {
|
||||
this.path = path;
|
||||
this.matcher = matcher;
|
||||
this.delegate = delegate;
|
||||
};
|
||||
Target.prototype.to = function to (target, callback) {
|
||||
var delegate = this.delegate;
|
||||
if (delegate && delegate.willAddRoute) {
|
||||
target = delegate.willAddRoute(this.matcher.target, target);
|
||||
}
|
||||
this.matcher.add(this.path, target);
|
||||
if (callback) {
|
||||
if (callback.length === 0) {
|
||||
throw new Error("You must have an argument in the function passed to `to`");
|
||||
}
|
||||
this.matcher.addChild(this.path, target, callback, this.delegate);
|
||||
}
|
||||
};
|
||||
var Matcher = function Matcher(target) {
|
||||
this.routes = createMap();
|
||||
this.children = createMap();
|
||||
this.target = target;
|
||||
};
|
||||
Matcher.prototype.add = function add (path, target) {
|
||||
this.routes[path] = target;
|
||||
};
|
||||
Matcher.prototype.addChild = function addChild (path, target, callback, delegate) {
|
||||
var matcher = new Matcher(target);
|
||||
this.children[path] = matcher;
|
||||
var match = generateMatch(path, matcher, delegate);
|
||||
if (delegate && delegate.contextEntered) {
|
||||
delegate.contextEntered(target, match);
|
||||
}
|
||||
callback(match);
|
||||
};
|
||||
function generateMatch(startingPath, matcher, delegate) {
|
||||
function match(path, callback) {
|
||||
var fullPath = startingPath + path;
|
||||
if (callback) {
|
||||
callback(generateMatch(fullPath, matcher, delegate));
|
||||
}
|
||||
else {
|
||||
return new Target(fullPath, matcher, delegate);
|
||||
}
|
||||
}
|
||||
|
||||
return match;
|
||||
}
|
||||
function addRoute(routeArray, path, handler) {
|
||||
var len = 0;
|
||||
for (var i = 0; i < routeArray.length; i++) {
|
||||
len += routeArray[i].path.length;
|
||||
}
|
||||
path = path.substr(len);
|
||||
var route = { path: path, handler: handler };
|
||||
routeArray.push(route);
|
||||
}
|
||||
function eachRoute(baseRoute, matcher, callback, binding) {
|
||||
var routes = matcher.routes;
|
||||
var paths = Object.keys(routes);
|
||||
for (var i = 0; i < paths.length; i++) {
|
||||
var path = paths[i];
|
||||
var routeArray = baseRoute.slice();
|
||||
addRoute(routeArray, path, routes[path]);
|
||||
var nested = matcher.children[path];
|
||||
if (nested) {
|
||||
eachRoute(routeArray, nested, callback, binding);
|
||||
}
|
||||
else {
|
||||
callback.call(binding, routeArray);
|
||||
}
|
||||
}
|
||||
}
|
||||
var map = function (callback, addRouteCallback) {
|
||||
var matcher = new Matcher();
|
||||
callback(generateMatch("", matcher, this.delegate));
|
||||
eachRoute([], matcher, function (routes) {
|
||||
if (addRouteCallback) {
|
||||
addRouteCallback(this, routes);
|
||||
}
|
||||
else {
|
||||
this.add(routes);
|
||||
}
|
||||
}, this);
|
||||
};
|
||||
|
||||
// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded
|
||||
// values that are not reserved (i.e., unicode characters, emoji, etc). The reserved
|
||||
// chars are "/" and "%".
|
||||
// Safe to call multiple times on the same path.
|
||||
// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded
|
||||
function normalizePath(path) {
|
||||
return path.split("/")
|
||||
.map(normalizeSegment)
|
||||
.join("/");
|
||||
}
|
||||
// We want to ensure the characters "%" and "/" remain in percent-encoded
|
||||
// form when normalizing paths, so replace them with their encoded form after
|
||||
// decoding the rest of the path
|
||||
var SEGMENT_RESERVED_CHARS = /%|\//g;
|
||||
function normalizeSegment(segment) {
|
||||
if (segment.length < 3 || segment.indexOf("%") === -1)
|
||||
{ return segment; }
|
||||
return decodeURIComponent(segment).replace(SEGMENT_RESERVED_CHARS, encodeURIComponent);
|
||||
}
|
||||
// We do not want to encode these characters when generating dynamic path segments
|
||||
// See https://tools.ietf.org/html/rfc3986#section-3.3
|
||||
// sub-delims: "!", "$", "&", "'", "(", ")", "*", "+", ",", ";", "="
|
||||
// others allowed by RFC 3986: ":", "@"
|
||||
//
|
||||
// First encode the entire path segment, then decode any of the encoded special chars.
|
||||
//
|
||||
// The chars "!", "'", "(", ")", "*" do not get changed by `encodeURIComponent`,
|
||||
// so the possible encoded chars are:
|
||||
// ['%24', '%26', '%2B', '%2C', '%3B', '%3D', '%3A', '%40'].
|
||||
var PATH_SEGMENT_ENCODINGS = /%(?:2(?:4|6|B|C)|3(?:B|D|A)|40)/g;
|
||||
function encodePathSegment(str) {
|
||||
return encodeURIComponent(str).replace(PATH_SEGMENT_ENCODINGS, decodeURIComponent);
|
||||
}
|
||||
|
||||
var escapeRegex = /(\/|\.|\*|\+|\?|\||\(|\)|\[|\]|\{|\}|\\)/g;
|
||||
var isArray = Array.isArray;
|
||||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
function getParam(params, key) {
|
||||
if (typeof params !== "object" || params === null) {
|
||||
throw new Error("You must pass an object as the second argument to `generate`.");
|
||||
}
|
||||
if (!hasOwnProperty.call(params, key)) {
|
||||
throw new Error("You must provide param `" + key + "` to `generate`.");
|
||||
}
|
||||
var value = params[key];
|
||||
var str = typeof value === "string" ? value : "" + value;
|
||||
if (str.length === 0) {
|
||||
throw new Error("You must provide a param `" + key + "`.");
|
||||
}
|
||||
return str;
|
||||
}
|
||||
var eachChar = [];
|
||||
eachChar[0 /* Static */] = function (segment, currentState) {
|
||||
var state = currentState;
|
||||
var value = segment.value;
|
||||
for (var i = 0; i < value.length; i++) {
|
||||
var ch = value.charCodeAt(i);
|
||||
state = state.put(ch, false, false);
|
||||
}
|
||||
return state;
|
||||
};
|
||||
eachChar[1 /* Dynamic */] = function (_, currentState) {
|
||||
return currentState.put(47 /* SLASH */, true, true);
|
||||
};
|
||||
eachChar[2 /* Star */] = function (_, currentState) {
|
||||
return currentState.put(-1 /* ANY */, false, true);
|
||||
};
|
||||
eachChar[4 /* Epsilon */] = function (_, currentState) {
|
||||
return currentState;
|
||||
};
|
||||
var regex = [];
|
||||
regex[0 /* Static */] = function (segment) {
|
||||
return segment.value.replace(escapeRegex, "\\$1");
|
||||
};
|
||||
regex[1 /* Dynamic */] = function () {
|
||||
return "([^/]+)";
|
||||
};
|
||||
regex[2 /* Star */] = function () {
|
||||
return "(.+)";
|
||||
};
|
||||
regex[4 /* Epsilon */] = function () {
|
||||
return "";
|
||||
};
|
||||
var generate = [];
|
||||
generate[0 /* Static */] = function (segment) {
|
||||
return segment.value;
|
||||
};
|
||||
generate[1 /* Dynamic */] = function (segment, params) {
|
||||
var value = getParam(params, segment.value);
|
||||
if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {
|
||||
return encodePathSegment(value);
|
||||
}
|
||||
else {
|
||||
return value;
|
||||
}
|
||||
};
|
||||
generate[2 /* Star */] = function (segment, params) {
|
||||
return getParam(params, segment.value);
|
||||
};
|
||||
generate[4 /* Epsilon */] = function () {
|
||||
return "";
|
||||
};
|
||||
var EmptyObject = Object.freeze({});
|
||||
var EmptyArray = Object.freeze([]);
|
||||
// The `names` will be populated with the paramter name for each dynamic/star
|
||||
// segment. `shouldDecodes` will be populated with a boolean for each dyanamic/star
|
||||
// segment, indicating whether it should be decoded during recognition.
|
||||
function parse(segments, route, types) {
|
||||
// normalize route as not starting with a "/". Recognition will
|
||||
// also normalize.
|
||||
if (route.length > 0 && route.charCodeAt(0) === 47 /* SLASH */) {
|
||||
route = route.substr(1);
|
||||
}
|
||||
var parts = route.split("/");
|
||||
var names = undefined;
|
||||
var shouldDecodes = undefined;
|
||||
for (var i = 0; i < parts.length; i++) {
|
||||
var part = parts[i];
|
||||
var flags = 0;
|
||||
var type = 0;
|
||||
if (part === "") {
|
||||
type = 4 /* Epsilon */;
|
||||
}
|
||||
else if (part.charCodeAt(0) === 58 /* COLON */) {
|
||||
type = 1 /* Dynamic */;
|
||||
}
|
||||
else if (part.charCodeAt(0) === 42 /* STAR */) {
|
||||
type = 2 /* Star */;
|
||||
}
|
||||
else {
|
||||
type = 0 /* Static */;
|
||||
}
|
||||
flags = 2 << type;
|
||||
if (flags & 12 /* Named */) {
|
||||
part = part.slice(1);
|
||||
names = names || [];
|
||||
names.push(part);
|
||||
shouldDecodes = shouldDecodes || [];
|
||||
shouldDecodes.push((flags & 4 /* Decoded */) !== 0);
|
||||
}
|
||||
if (flags & 14 /* Counted */) {
|
||||
types[type]++;
|
||||
}
|
||||
segments.push({
|
||||
type: type,
|
||||
value: normalizeSegment(part)
|
||||
});
|
||||
}
|
||||
return {
|
||||
names: names || EmptyArray,
|
||||
shouldDecodes: shouldDecodes || EmptyArray,
|
||||
};
|
||||
}
|
||||
function isEqualCharSpec(spec, char, negate) {
|
||||
return spec.char === char && spec.negate === negate;
|
||||
}
|
||||
// A State has a character specification and (`charSpec`) and a list of possible
|
||||
// subsequent states (`nextStates`).
|
||||
//
|
||||
// If a State is an accepting state, it will also have several additional
|
||||
// properties:
|
||||
//
|
||||
// * `regex`: A regular expression that is used to extract parameters from paths
|
||||
// that reached this accepting state.
|
||||
// * `handlers`: Information on how to convert the list of captures into calls
|
||||
// to registered handlers with the specified parameters
|
||||
// * `types`: How many static, dynamic or star segments in this route. Used to
|
||||
// decide which route to use if multiple registered routes match a path.
|
||||
//
|
||||
// Currently, State is implemented naively by looping over `nextStates` and
|
||||
// comparing a character specification against a character. A more efficient
|
||||
// implementation would use a hash of keys pointing at one or more next states.
|
||||
var State = function State(states, id, char, negate, repeat) {
|
||||
this.states = states;
|
||||
this.id = id;
|
||||
this.char = char;
|
||||
this.negate = negate;
|
||||
this.nextStates = repeat ? id : null;
|
||||
this.pattern = "";
|
||||
this._regex = undefined;
|
||||
this.handlers = undefined;
|
||||
this.types = undefined;
|
||||
};
|
||||
State.prototype.regex = function regex$1 () {
|
||||
if (!this._regex) {
|
||||
this._regex = new RegExp(this.pattern);
|
||||
}
|
||||
return this._regex;
|
||||
};
|
||||
State.prototype.get = function get (char, negate) {
|
||||
var this$1 = this;
|
||||
|
||||
var nextStates = this.nextStates;
|
||||
if (nextStates === null)
|
||||
{ return; }
|
||||
if (isArray(nextStates)) {
|
||||
for (var i = 0; i < nextStates.length; i++) {
|
||||
var child = this$1.states[nextStates[i]];
|
||||
if (isEqualCharSpec(child, char, negate)) {
|
||||
return child;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
var child$1 = this.states[nextStates];
|
||||
if (isEqualCharSpec(child$1, char, negate)) {
|
||||
return child$1;
|
||||
}
|
||||
}
|
||||
};
|
||||
State.prototype.put = function put (char, negate, repeat) {
|
||||
var state;
|
||||
// If the character specification already exists in a child of the current
|
||||
// state, just return that state.
|
||||
if (state = this.get(char, negate)) {
|
||||
return state;
|
||||
}
|
||||
// Make a new state for the character spec
|
||||
var states = this.states;
|
||||
state = new State(states, states.length, char, negate, repeat);
|
||||
states[states.length] = state;
|
||||
// Insert the new state as a child of the current state
|
||||
if (this.nextStates == null) {
|
||||
this.nextStates = state.id;
|
||||
}
|
||||
else if (isArray(this.nextStates)) {
|
||||
this.nextStates.push(state.id);
|
||||
}
|
||||
else {
|
||||
this.nextStates = [this.nextStates, state.id];
|
||||
}
|
||||
// Return the new state
|
||||
return state;
|
||||
};
|
||||
// Find a list of child states matching the next character
|
||||
State.prototype.match = function match (ch) {
|
||||
var this$1 = this;
|
||||
|
||||
var nextStates = this.nextStates;
|
||||
if (!nextStates)
|
||||
{ return []; }
|
||||
var returned = [];
|
||||
if (isArray(nextStates)) {
|
||||
for (var i = 0; i < nextStates.length; i++) {
|
||||
var child = this$1.states[nextStates[i]];
|
||||
if (isMatch(child, ch)) {
|
||||
returned.push(child);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
var child$1 = this.states[nextStates];
|
||||
if (isMatch(child$1, ch)) {
|
||||
returned.push(child$1);
|
||||
}
|
||||
}
|
||||
return returned;
|
||||
};
|
||||
function isMatch(spec, char) {
|
||||
return spec.negate ? spec.char !== char && spec.char !== -1 /* ANY */ : spec.char === char || spec.char === -1 /* ANY */;
|
||||
}
|
||||
// This is a somewhat naive strategy, but should work in a lot of cases
|
||||
// A better strategy would properly resolve /posts/:id/new and /posts/edit/:id.
|
||||
//
|
||||
// This strategy generally prefers more static and less dynamic matching.
|
||||
// Specifically, it
|
||||
//
|
||||
// * prefers fewer stars to more, then
|
||||
// * prefers using stars for less of the match to more, then
|
||||
// * prefers fewer dynamic segments to more, then
|
||||
// * prefers more static segments to more
|
||||
function sortSolutions(states) {
|
||||
return states.sort(function (a, b) {
|
||||
var ref = a.types || [0, 0, 0];
|
||||
var astatics = ref[0];
|
||||
var adynamics = ref[1];
|
||||
var astars = ref[2];
|
||||
var ref$1 = b.types || [0, 0, 0];
|
||||
var bstatics = ref$1[0];
|
||||
var bdynamics = ref$1[1];
|
||||
var bstars = ref$1[2];
|
||||
if (astars !== bstars) {
|
||||
return astars - bstars;
|
||||
}
|
||||
if (astars) {
|
||||
if (astatics !== bstatics) {
|
||||
return bstatics - astatics;
|
||||
}
|
||||
if (adynamics !== bdynamics) {
|
||||
return bdynamics - adynamics;
|
||||
}
|
||||
}
|
||||
if (adynamics !== bdynamics) {
|
||||
return adynamics - bdynamics;
|
||||
}
|
||||
if (astatics !== bstatics) {
|
||||
return bstatics - astatics;
|
||||
}
|
||||
return 0;
|
||||
});
|
||||
}
|
||||
function recognizeChar(states, ch) {
|
||||
var nextStates = [];
|
||||
for (var i = 0, l = states.length; i < l; i++) {
|
||||
var state = states[i];
|
||||
nextStates = nextStates.concat(state.match(ch));
|
||||
}
|
||||
return nextStates;
|
||||
}
|
||||
var RecognizeResults = function RecognizeResults(queryParams) {
|
||||
this.length = 0;
|
||||
this.queryParams = queryParams || {};
|
||||
};
|
||||
|
||||
RecognizeResults.prototype.splice = Array.prototype.splice;
|
||||
RecognizeResults.prototype.slice = Array.prototype.slice;
|
||||
RecognizeResults.prototype.push = Array.prototype.push;
|
||||
function findHandler(state, originalPath, queryParams) {
|
||||
var handlers = state.handlers;
|
||||
var regex = state.regex();
|
||||
if (!regex || !handlers)
|
||||
{ throw new Error("state not initialized"); }
|
||||
var captures = originalPath.match(regex);
|
||||
var currentCapture = 1;
|
||||
var result = new RecognizeResults(queryParams);
|
||||
result.length = handlers.length;
|
||||
for (var i = 0; i < handlers.length; i++) {
|
||||
var handler = handlers[i];
|
||||
var names = handler.names;
|
||||
var shouldDecodes = handler.shouldDecodes;
|
||||
var params = EmptyObject;
|
||||
var isDynamic = false;
|
||||
if (names !== EmptyArray && shouldDecodes !== EmptyArray) {
|
||||
for (var j = 0; j < names.length; j++) {
|
||||
isDynamic = true;
|
||||
var name = names[j];
|
||||
var capture = captures && captures[currentCapture++];
|
||||
if (params === EmptyObject) {
|
||||
params = {};
|
||||
}
|
||||
if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS && shouldDecodes[j]) {
|
||||
params[name] = capture && decodeURIComponent(capture);
|
||||
}
|
||||
else {
|
||||
params[name] = capture;
|
||||
}
|
||||
}
|
||||
}
|
||||
result[i] = {
|
||||
handler: handler.handler,
|
||||
params: params,
|
||||
isDynamic: isDynamic
|
||||
};
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function decodeQueryParamPart(part) {
|
||||
// http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1
|
||||
part = part.replace(/\+/gm, "%20");
|
||||
var result;
|
||||
try {
|
||||
result = decodeURIComponent(part);
|
||||
}
|
||||
catch (error) {
|
||||
result = "";
|
||||
}
|
||||
return result;
|
||||
}
|
||||
var RouteRecognizer = function RouteRecognizer() {
|
||||
this.names = createMap();
|
||||
var states = [];
|
||||
var state = new State(states, 0, -1 /* ANY */, true, false);
|
||||
states[0] = state;
|
||||
this.states = states;
|
||||
this.rootState = state;
|
||||
};
|
||||
RouteRecognizer.prototype.add = function add (routes, options) {
|
||||
var currentState = this.rootState;
|
||||
var pattern = "^";
|
||||
var types = [0, 0, 0];
|
||||
var handlers = new Array(routes.length);
|
||||
var allSegments = [];
|
||||
var isEmpty = true;
|
||||
var j = 0;
|
||||
for (var i = 0; i < routes.length; i++) {
|
||||
var route = routes[i];
|
||||
var ref = parse(allSegments, route.path, types);
|
||||
var names = ref.names;
|
||||
var shouldDecodes = ref.shouldDecodes;
|
||||
// preserve j so it points to the start of newly added segments
|
||||
for (; j < allSegments.length; j++) {
|
||||
var segment = allSegments[j];
|
||||
if (segment.type === 4 /* Epsilon */) {
|
||||
continue;
|
||||
}
|
||||
isEmpty = false;
|
||||
// Add a "/" for the new segment
|
||||
currentState = currentState.put(47 /* SLASH */, false, false);
|
||||
pattern += "/";
|
||||
// Add a representation of the segment to the NFA and regex
|
||||
currentState = eachChar[segment.type](segment, currentState);
|
||||
pattern += regex[segment.type](segment);
|
||||
}
|
||||
handlers[i] = {
|
||||
handler: route.handler,
|
||||
names: names,
|
||||
shouldDecodes: shouldDecodes
|
||||
};
|
||||
}
|
||||
if (isEmpty) {
|
||||
currentState = currentState.put(47 /* SLASH */, false, false);
|
||||
pattern += "/";
|
||||
}
|
||||
currentState.handlers = handlers;
|
||||
currentState.pattern = pattern + "$";
|
||||
currentState.types = types;
|
||||
var name;
|
||||
if (typeof options === "object" && options !== null && options.as) {
|
||||
name = options.as;
|
||||
}
|
||||
if (name) {
|
||||
// if (this.names[name]) {
|
||||
// throw new Error("You may not add a duplicate route named `" + name + "`.");
|
||||
// }
|
||||
this.names[name] = {
|
||||
segments: allSegments,
|
||||
handlers: handlers
|
||||
};
|
||||
}
|
||||
};
|
||||
RouteRecognizer.prototype.handlersFor = function handlersFor (name) {
|
||||
var route = this.names[name];
|
||||
if (!route) {
|
||||
throw new Error("There is no route named " + name);
|
||||
}
|
||||
var result = new Array(route.handlers.length);
|
||||
for (var i = 0; i < route.handlers.length; i++) {
|
||||
var handler = route.handlers[i];
|
||||
result[i] = handler;
|
||||
}
|
||||
return result;
|
||||
};
|
||||
RouteRecognizer.prototype.hasRoute = function hasRoute (name) {
|
||||
return !!this.names[name];
|
||||
};
|
||||
RouteRecognizer.prototype.generate = function generate$1 (name, params) {
|
||||
var route = this.names[name];
|
||||
var output = "";
|
||||
if (!route) {
|
||||
throw new Error("There is no route named " + name);
|
||||
}
|
||||
var segments = route.segments;
|
||||
for (var i = 0; i < segments.length; i++) {
|
||||
var segment = segments[i];
|
||||
if (segment.type === 4 /* Epsilon */) {
|
||||
continue;
|
||||
}
|
||||
output += "/";
|
||||
output += generate[segment.type](segment, params);
|
||||
}
|
||||
if (output.charAt(0) !== "/") {
|
||||
output = "/" + output;
|
||||
}
|
||||
if (params && params.queryParams) {
|
||||
output += this.generateQueryString(params.queryParams);
|
||||
}
|
||||
return output;
|
||||
};
|
||||
RouteRecognizer.prototype.generateQueryString = function generateQueryString (params) {
|
||||
var pairs = [];
|
||||
var keys = Object.keys(params);
|
||||
keys.sort();
|
||||
for (var i = 0; i < keys.length; i++) {
|
||||
var key = keys[i];
|
||||
var value = params[key];
|
||||
if (value == null) {
|
||||
continue;
|
||||
}
|
||||
var pair = encodeURIComponent(key);
|
||||
if (isArray(value)) {
|
||||
for (var j = 0; j < value.length; j++) {
|
||||
var arrayPair = key + "[]" + "=" + encodeURIComponent(value[j]);
|
||||
pairs.push(arrayPair);
|
||||
}
|
||||
}
|
||||
else {
|
||||
pair += "=" + encodeURIComponent(value);
|
||||
pairs.push(pair);
|
||||
}
|
||||
}
|
||||
if (pairs.length === 0) {
|
||||
return "";
|
||||
}
|
||||
return "?" + pairs.join("&");
|
||||
};
|
||||
RouteRecognizer.prototype.parseQueryString = function parseQueryString (queryString) {
|
||||
var pairs = queryString.split("&");
|
||||
var queryParams = {};
|
||||
for (var i = 0; i < pairs.length; i++) {
|
||||
var pair = pairs[i].split("="), key = decodeQueryParamPart(pair[0]), keyLength = key.length, isArray = false, value = (void 0);
|
||||
if (pair.length === 1) {
|
||||
value = "true";
|
||||
}
|
||||
else {
|
||||
// Handle arrays
|
||||
if (keyLength > 2 && key.slice(keyLength - 2) === "[]") {
|
||||
isArray = true;
|
||||
key = key.slice(0, keyLength - 2);
|
||||
if (!queryParams[key]) {
|
||||
queryParams[key] = [];
|
||||
}
|
||||
}
|
||||
value = pair[1] ? decodeQueryParamPart(pair[1]) : "";
|
||||
}
|
||||
if (isArray) {
|
||||
queryParams[key].push(value);
|
||||
}
|
||||
else {
|
||||
queryParams[key] = value;
|
||||
}
|
||||
}
|
||||
return queryParams;
|
||||
};
|
||||
RouteRecognizer.prototype.recognize = function recognize (path) {
|
||||
var results;
|
||||
var states = [this.rootState];
|
||||
var queryParams = {};
|
||||
var isSlashDropped = false;
|
||||
var hashStart = path.indexOf("#");
|
||||
if (hashStart !== -1) {
|
||||
path = path.substr(0, hashStart);
|
||||
}
|
||||
var queryStart = path.indexOf("?");
|
||||
if (queryStart !== -1) {
|
||||
var queryString = path.substr(queryStart + 1, path.length);
|
||||
path = path.substr(0, queryStart);
|
||||
queryParams = this.parseQueryString(queryString);
|
||||
}
|
||||
if (path.charAt(0) !== "/") {
|
||||
path = "/" + path;
|
||||
}
|
||||
var originalPath = path;
|
||||
if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {
|
||||
path = normalizePath(path);
|
||||
}
|
||||
else {
|
||||
path = decodeURI(path);
|
||||
originalPath = decodeURI(originalPath);
|
||||
}
|
||||
var pathLen = path.length;
|
||||
if (pathLen > 1 && path.charAt(pathLen - 1) === "/") {
|
||||
path = path.substr(0, pathLen - 1);
|
||||
originalPath = originalPath.substr(0, originalPath.length - 1);
|
||||
isSlashDropped = true;
|
||||
}
|
||||
for (var i = 0; i < path.length; i++) {
|
||||
states = recognizeChar(states, path.charCodeAt(i));
|
||||
if (!states.length) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
var solutions = [];
|
||||
for (var i$1 = 0; i$1 < states.length; i$1++) {
|
||||
if (states[i$1].handlers) {
|
||||
solutions.push(states[i$1]);
|
||||
}
|
||||
}
|
||||
states = sortSolutions(solutions);
|
||||
var state = solutions[0];
|
||||
if (state && state.handlers) {
|
||||
// if a trailing slash was dropped and a star segment is the last segment
|
||||
// specified, put the trailing slash back
|
||||
if (isSlashDropped && state.pattern && state.pattern.slice(-5) === "(.+)$") {
|
||||
originalPath = originalPath + "/";
|
||||
}
|
||||
results = findHandler(state, originalPath, queryParams);
|
||||
}
|
||||
return results;
|
||||
};
|
||||
RouteRecognizer.VERSION = "0.3.4";
|
||||
// Set to false to opt-out of encoding and decoding path segments.
|
||||
// See https://github.com/tildeio/route-recognizer/pull/55
|
||||
RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS = true;
|
||||
RouteRecognizer.Normalizer = {
|
||||
normalizeSegment: normalizeSegment, normalizePath: normalizePath, encodePathSegment: encodePathSegment
|
||||
};
|
||||
RouteRecognizer.prototype.map = map;
|
||||
|
||||
return RouteRecognizer;
|
||||
|
||||
})));
|
||||
|
||||
//# sourceMappingURL=route-recognizer.js.map
|
||||
Loading…
Reference in New Issue