1383 lines
38 KiB
JavaScript
1383 lines
38 KiB
JavaScript
import { __, pure } from 'riot';
|
|
|
|
/**
|
|
* Tokenize input string.
|
|
*/
|
|
function lexer(str) {
|
|
var tokens = [];
|
|
var i = 0;
|
|
|
|
while (i < str.length) {
|
|
var char = str[i];
|
|
|
|
if (char === "*" || char === "+" || char === "?") {
|
|
tokens.push({
|
|
type: "MODIFIER",
|
|
index: i,
|
|
value: str[i++]
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (char === "\\") {
|
|
tokens.push({
|
|
type: "ESCAPED_CHAR",
|
|
index: i++,
|
|
value: str[i++]
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (char === "{") {
|
|
tokens.push({
|
|
type: "OPEN",
|
|
index: i,
|
|
value: str[i++]
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (char === "}") {
|
|
tokens.push({
|
|
type: "CLOSE",
|
|
index: i,
|
|
value: str[i++]
|
|
});
|
|
continue;
|
|
}
|
|
|
|
if (char === ":") {
|
|
var name = "";
|
|
var j = i + 1;
|
|
|
|
while (j < str.length) {
|
|
var code = str.charCodeAt(j);
|
|
|
|
if ( // `0-9`
|
|
code >= 48 && code <= 57 || // `A-Z`
|
|
code >= 65 && code <= 90 || // `a-z`
|
|
code >= 97 && code <= 122 || // `_`
|
|
code === 95) {
|
|
name += str[j++];
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (!name) throw new TypeError("Missing parameter name at " + i);
|
|
tokens.push({
|
|
type: "NAME",
|
|
index: i,
|
|
value: name
|
|
});
|
|
i = j;
|
|
continue;
|
|
}
|
|
|
|
if (char === "(") {
|
|
var count = 1;
|
|
var pattern = "";
|
|
var j = i + 1;
|
|
|
|
if (str[j] === "?") {
|
|
throw new TypeError("Pattern cannot start with \"?\" at " + j);
|
|
}
|
|
|
|
while (j < str.length) {
|
|
if (str[j] === "\\") {
|
|
pattern += str[j++] + str[j++];
|
|
continue;
|
|
}
|
|
|
|
if (str[j] === ")") {
|
|
count--;
|
|
|
|
if (count === 0) {
|
|
j++;
|
|
break;
|
|
}
|
|
} else if (str[j] === "(") {
|
|
count++;
|
|
|
|
if (str[j + 1] !== "?") {
|
|
throw new TypeError("Capturing groups are not allowed at " + j);
|
|
}
|
|
}
|
|
|
|
pattern += str[j++];
|
|
}
|
|
|
|
if (count) throw new TypeError("Unbalanced pattern at " + i);
|
|
if (!pattern) throw new TypeError("Missing pattern at " + i);
|
|
tokens.push({
|
|
type: "PATTERN",
|
|
index: i,
|
|
value: pattern
|
|
});
|
|
i = j;
|
|
continue;
|
|
}
|
|
|
|
tokens.push({
|
|
type: "CHAR",
|
|
index: i,
|
|
value: str[i++]
|
|
});
|
|
}
|
|
|
|
tokens.push({
|
|
type: "END",
|
|
index: i,
|
|
value: ""
|
|
});
|
|
return tokens;
|
|
}
|
|
/**
|
|
* Parse a string for the raw tokens.
|
|
*/
|
|
|
|
|
|
function parse(str, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
var tokens = lexer(str);
|
|
var _a = options.prefixes,
|
|
prefixes = _a === void 0 ? "./" : _a;
|
|
var defaultPattern = "[^" + escapeString(options.delimiter || "/#?") + "]+?";
|
|
var result = [];
|
|
var key = 0;
|
|
var i = 0;
|
|
var path = "";
|
|
|
|
var tryConsume = function tryConsume(type) {
|
|
if (i < tokens.length && tokens[i].type === type) return tokens[i++].value;
|
|
};
|
|
|
|
var mustConsume = function mustConsume(type) {
|
|
var value = tryConsume(type);
|
|
if (value !== undefined) return value;
|
|
var _a = tokens[i],
|
|
nextType = _a.type,
|
|
index = _a.index;
|
|
throw new TypeError("Unexpected " + nextType + " at " + index + ", expected " + type);
|
|
};
|
|
|
|
var consumeText = function consumeText() {
|
|
var result = "";
|
|
var value; // tslint:disable-next-line
|
|
|
|
while (value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
|
|
result += value;
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
while (i < tokens.length) {
|
|
var char = tryConsume("CHAR");
|
|
var name = tryConsume("NAME");
|
|
var pattern = tryConsume("PATTERN");
|
|
|
|
if (name || pattern) {
|
|
var prefix = char || "";
|
|
|
|
if (prefixes.indexOf(prefix) === -1) {
|
|
path += prefix;
|
|
prefix = "";
|
|
}
|
|
|
|
if (path) {
|
|
result.push(path);
|
|
path = "";
|
|
}
|
|
|
|
result.push({
|
|
name: name || key++,
|
|
prefix: prefix,
|
|
suffix: "",
|
|
pattern: pattern || defaultPattern,
|
|
modifier: tryConsume("MODIFIER") || ""
|
|
});
|
|
continue;
|
|
}
|
|
|
|
var value = char || tryConsume("ESCAPED_CHAR");
|
|
|
|
if (value) {
|
|
path += value;
|
|
continue;
|
|
}
|
|
|
|
if (path) {
|
|
result.push(path);
|
|
path = "";
|
|
}
|
|
|
|
var open = tryConsume("OPEN");
|
|
|
|
if (open) {
|
|
var prefix = consumeText();
|
|
var name_1 = tryConsume("NAME") || "";
|
|
var pattern_1 = tryConsume("PATTERN") || "";
|
|
var suffix = consumeText();
|
|
mustConsume("CLOSE");
|
|
result.push({
|
|
name: name_1 || (pattern_1 ? key++ : ""),
|
|
pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
|
|
prefix: prefix,
|
|
suffix: suffix,
|
|
modifier: tryConsume("MODIFIER") || ""
|
|
});
|
|
continue;
|
|
}
|
|
|
|
mustConsume("END");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
/**
|
|
* Compile a string to a template function for the path.
|
|
*/
|
|
|
|
function compile(str, options) {
|
|
return tokensToFunction(parse(str, options), options);
|
|
}
|
|
/**
|
|
* Expose a method for transforming tokens into the path function.
|
|
*/
|
|
|
|
function tokensToFunction(tokens, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
var reFlags = flags(options);
|
|
var _a = options.encode,
|
|
encode = _a === void 0 ? function (x) {
|
|
return x;
|
|
} : _a,
|
|
_b = options.validate,
|
|
validate = _b === void 0 ? true : _b; // Compile all the tokens into regexps.
|
|
|
|
var matches = tokens.map(function (token) {
|
|
if (typeof token === "object") {
|
|
return new RegExp("^(?:" + token.pattern + ")$", reFlags);
|
|
}
|
|
});
|
|
return function (data) {
|
|
var path = "";
|
|
|
|
for (var i = 0; i < tokens.length; i++) {
|
|
var token = tokens[i];
|
|
|
|
if (typeof token === "string") {
|
|
path += token;
|
|
continue;
|
|
}
|
|
|
|
var value = data ? data[token.name] : undefined;
|
|
var optional = token.modifier === "?" || token.modifier === "*";
|
|
var repeat = token.modifier === "*" || token.modifier === "+";
|
|
|
|
if (Array.isArray(value)) {
|
|
if (!repeat) {
|
|
throw new TypeError("Expected \"" + token.name + "\" to not repeat, but got an array");
|
|
}
|
|
|
|
if (value.length === 0) {
|
|
if (optional) continue;
|
|
throw new TypeError("Expected \"" + token.name + "\" to not be empty");
|
|
}
|
|
|
|
for (var j = 0; j < value.length; j++) {
|
|
var segment = encode(value[j], token);
|
|
|
|
if (validate && !matches[i].test(segment)) {
|
|
throw new TypeError("Expected all \"" + token.name + "\" to match \"" + token.pattern + "\", but got \"" + segment + "\"");
|
|
}
|
|
|
|
path += token.prefix + segment + token.suffix;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (typeof value === "string" || typeof value === "number") {
|
|
var segment = encode(String(value), token);
|
|
|
|
if (validate && !matches[i].test(segment)) {
|
|
throw new TypeError("Expected \"" + token.name + "\" to match \"" + token.pattern + "\", but got \"" + segment + "\"");
|
|
}
|
|
|
|
path += token.prefix + segment + token.suffix;
|
|
continue;
|
|
}
|
|
|
|
if (optional) continue;
|
|
var typeOfMessage = repeat ? "an array" : "a string";
|
|
throw new TypeError("Expected \"" + token.name + "\" to be " + typeOfMessage);
|
|
}
|
|
|
|
return path;
|
|
};
|
|
}
|
|
/**
|
|
* Escape a regular expression string.
|
|
*/
|
|
|
|
function escapeString(str) {
|
|
return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
|
|
}
|
|
/**
|
|
* Get the flags for a regexp from the options.
|
|
*/
|
|
|
|
|
|
function flags(options) {
|
|
return options && options.sensitive ? "" : "i";
|
|
}
|
|
/**
|
|
* Pull out keys from a regexp.
|
|
*/
|
|
|
|
|
|
function regexpToRegexp(path, keys) {
|
|
if (!keys) return path;
|
|
var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
|
|
var index = 0;
|
|
var execResult = groupsRegex.exec(path.source);
|
|
|
|
while (execResult) {
|
|
keys.push({
|
|
// Use parenthesized substring match if available, index otherwise
|
|
name: execResult[1] || index++,
|
|
prefix: "",
|
|
suffix: "",
|
|
modifier: "",
|
|
pattern: ""
|
|
});
|
|
execResult = groupsRegex.exec(path.source);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
/**
|
|
* Transform an array into a regexp.
|
|
*/
|
|
|
|
|
|
function arrayToRegexp(paths, keys, options) {
|
|
var parts = paths.map(function (path) {
|
|
return pathToRegexp(path, keys, options).source;
|
|
});
|
|
return new RegExp("(?:" + parts.join("|") + ")", flags(options));
|
|
}
|
|
/**
|
|
* Create a path regexp from string input.
|
|
*/
|
|
|
|
|
|
function stringToRegexp(path, keys, options) {
|
|
return tokensToRegexp(parse(path, options), keys, options);
|
|
}
|
|
/**
|
|
* Expose a function for taking tokens and returning a RegExp.
|
|
*/
|
|
|
|
|
|
function tokensToRegexp(tokens, keys, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
var _a = options.strict,
|
|
strict = _a === void 0 ? false : _a,
|
|
_b = options.start,
|
|
start = _b === void 0 ? true : _b,
|
|
_c = options.end,
|
|
end = _c === void 0 ? true : _c,
|
|
_d = options.encode,
|
|
encode = _d === void 0 ? function (x) {
|
|
return x;
|
|
} : _d;
|
|
var endsWith = "[" + escapeString(options.endsWith || "") + "]|$";
|
|
var delimiter = "[" + escapeString(options.delimiter || "/#?") + "]";
|
|
var route = start ? "^" : ""; // Iterate over the tokens and create our regexp string.
|
|
|
|
for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
|
|
var token = tokens_1[_i];
|
|
|
|
if (typeof token === "string") {
|
|
route += escapeString(encode(token));
|
|
} else {
|
|
var prefix = escapeString(encode(token.prefix));
|
|
var suffix = escapeString(encode(token.suffix));
|
|
|
|
if (token.pattern) {
|
|
if (keys) keys.push(token);
|
|
|
|
if (prefix || suffix) {
|
|
if (token.modifier === "+" || token.modifier === "*") {
|
|
var mod = token.modifier === "*" ? "?" : "";
|
|
route += "(?:" + prefix + "((?:" + token.pattern + ")(?:" + suffix + prefix + "(?:" + token.pattern + "))*)" + suffix + ")" + mod;
|
|
} else {
|
|
route += "(?:" + prefix + "(" + token.pattern + ")" + suffix + ")" + token.modifier;
|
|
}
|
|
} else {
|
|
route += "(" + token.pattern + ")" + token.modifier;
|
|
}
|
|
} else {
|
|
route += "(?:" + prefix + suffix + ")" + token.modifier;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (end) {
|
|
if (!strict) route += delimiter + "?";
|
|
route += !options.endsWith ? "$" : "(?=" + endsWith + ")";
|
|
} else {
|
|
var endToken = tokens[tokens.length - 1];
|
|
var isEndDelimited = typeof endToken === "string" ? delimiter.indexOf(endToken[endToken.length - 1]) > -1 : // tslint:disable-next-line
|
|
endToken === undefined;
|
|
|
|
if (!strict) {
|
|
route += "(?:" + delimiter + "(?=" + endsWith + "))?";
|
|
}
|
|
|
|
if (!isEndDelimited) {
|
|
route += "(?=" + delimiter + "|" + endsWith + ")";
|
|
}
|
|
}
|
|
|
|
return new RegExp(route, flags(options));
|
|
}
|
|
/**
|
|
* Normalize the given path string, returning a regular expression.
|
|
*
|
|
* An empty array can be passed in for the keys, which will hold the
|
|
* placeholder key descriptions. For example, using `/user/:id`, `keys` will
|
|
* contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
|
|
*/
|
|
|
|
function pathToRegexp(path, keys, options) {
|
|
if (path instanceof RegExp) return regexpToRegexp(path, keys);
|
|
if (Array.isArray(path)) return arrayToRegexp(path, keys, options);
|
|
return stringToRegexp(path, keys, options);
|
|
}
|
|
|
|
/**
|
|
* Cancel token
|
|
* @private
|
|
* @type { Symbol }
|
|
*/
|
|
const CANCEL = Symbol();
|
|
/**
|
|
* Helper that can be returned by ruit function to cancel the tasks chain
|
|
* @returns { Symbol } internal private constant
|
|
* @example
|
|
*
|
|
* ruit(
|
|
* 100,
|
|
* num => Math.random() * num
|
|
* num => num > 50 ? ruit.cancel() : num
|
|
* num => num - 2
|
|
* ).then(result => {
|
|
* console.log(result) // here we will get only number lower than 50
|
|
* })
|
|
*
|
|
*/
|
|
|
|
ruit.cancel = () => CANCEL;
|
|
/**
|
|
* The same as ruit() but with the arguments inverted from right to left
|
|
* @param { * } tasks - list of tasks to process sequentially
|
|
* @returns { Promise } a promise containing the result of the whole chain
|
|
* @example
|
|
*
|
|
* const curry = f => a => b => f(a, b)
|
|
* const add = (a, b) => a + b
|
|
*
|
|
* const addOne = curry(add)(1)
|
|
*
|
|
* const squareAsync = (num) => {
|
|
* return new Promise(r => {
|
|
* setTimeout(r, 500, num * 2)
|
|
* })
|
|
* }
|
|
*
|
|
* // a -> a + a -> a * 2
|
|
* // basically from right to left: 1 => 1 + 1 => 2 * 2
|
|
* ruit.compose(squareAsync, addOne, 1).then(result => console.log(result)) // 4
|
|
*/
|
|
|
|
|
|
ruit.compose = function () {
|
|
for (var _len = arguments.length, tasks = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
tasks[_key] = arguments[_key];
|
|
}
|
|
|
|
return ruit(...tasks.reverse());
|
|
};
|
|
/**
|
|
* Serialize a list of sync and async tasks from left to right
|
|
* @param { * } tasks - list of tasks to process sequentially
|
|
* @returns { Promise } a promise containing the result of the whole chain
|
|
* @example
|
|
*
|
|
* const curry = f => a => b => f(a, b)
|
|
* const add = (a, b) => a + b
|
|
*
|
|
* const addOne = curry(add)(1)
|
|
*
|
|
* const squareAsync = (num) => {
|
|
* return new Promise(r => {
|
|
* setTimeout(r, 500, num * 2)
|
|
* })
|
|
* }
|
|
*
|
|
* // a -> a + a -> a * 2
|
|
* // basically from left to right: 1 => 1 + 1 => 2 * 2
|
|
* ruit(1, addOne, squareAsync).then(result => console.log(result)) // 4
|
|
*/
|
|
|
|
|
|
function ruit() {
|
|
for (var _len2 = arguments.length, tasks = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
tasks[_key2] = arguments[_key2];
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
return function run(queue, result) {
|
|
if (!queue.length) return resolve(result);
|
|
const [task, ...rest] = queue;
|
|
const value = typeof task === 'function' ? task(result) : task;
|
|
|
|
const done = v => run(rest, v); // check against nil values
|
|
|
|
|
|
if (value != null) {
|
|
if (value === CANCEL) return;
|
|
if (value.then) return value.then(done, reject);
|
|
}
|
|
|
|
return Promise.resolve(done(value));
|
|
}(tasks);
|
|
});
|
|
}
|
|
|
|
const API_METHODS = new Set();
|
|
const UNSUBSCRIBE_SYMBOL = Symbol();
|
|
const UNSUBSCRIBE_METHOD = 'off';
|
|
const CANCEL_METHOD = 'cancel';
|
|
/**
|
|
* Factory function to create the stream generator
|
|
* @private
|
|
* @param {Set} modifiers - stream input modifiers
|
|
* @returns {Generator} the stream generator
|
|
*/
|
|
|
|
function createStream(modifiers) {
|
|
const stream = function* stream() {
|
|
while (true) {
|
|
// get the initial stream value
|
|
const input = yield; // run the input sequence
|
|
|
|
yield ruit(input, ...modifiers);
|
|
}
|
|
}(); // start the stream
|
|
|
|
|
|
stream.next();
|
|
return stream;
|
|
}
|
|
/**
|
|
* Dispatch a value to several listeners
|
|
* @private
|
|
* @param {Set} callbacks - callbacks collection
|
|
* @param {*} value - anything
|
|
* @returns {Set} the callbacks received
|
|
*/
|
|
|
|
|
|
function dispatch(callbacks, value) {
|
|
callbacks.forEach(f => {
|
|
// unsubscribe the callback if erre.unsubscribe() will be returned
|
|
if (f(value) === UNSUBSCRIBE_SYMBOL) callbacks.delete(f);
|
|
});
|
|
return callbacks;
|
|
}
|
|
/**
|
|
* Throw a panic error
|
|
* @param {string} message - error message
|
|
* @returns {Error} an error object
|
|
*/
|
|
|
|
|
|
function panic$2(message) {
|
|
throw new Error(message);
|
|
}
|
|
/**
|
|
* Install an erre plugin adding it to the API
|
|
* @param {string} name - plugin name
|
|
* @param {Function} fn - new erre API method
|
|
* @returns {Function} return the erre function
|
|
*/
|
|
|
|
|
|
erre.install = function (name, fn) {
|
|
if (!name || typeof name !== 'string') panic$2('Please provide a name (as string) for your erre plugin');
|
|
if (!fn || typeof fn !== 'function') panic$2('Please provide a function for your erre plugin');
|
|
|
|
if (API_METHODS.has(name)) {
|
|
panic$2(`The ${name} is already part of the erre API, please provide a different name`);
|
|
} else {
|
|
erre[name] = fn;
|
|
API_METHODS.add(name);
|
|
}
|
|
|
|
return erre;
|
|
}; // alias for ruit canel to stop a stream chain
|
|
|
|
|
|
erre.install(CANCEL_METHOD, ruit.cancel); // unsubscribe helper
|
|
|
|
erre.install(UNSUBSCRIBE_METHOD, () => UNSUBSCRIBE_SYMBOL);
|
|
/**
|
|
* Stream constuction function
|
|
* @param {...Function} fns - stream modifiers
|
|
* @returns {Object} erre instance
|
|
*/
|
|
|
|
function erre() {
|
|
for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
fns[_key] = arguments[_key];
|
|
}
|
|
|
|
const [success, error, end, modifiers] = [new Set(), new Set(), new Set(), new Set(fns)],
|
|
generator = createStream(modifiers),
|
|
stream = Object.create(generator),
|
|
addToCollection = collection => fn => collection.add(fn) && stream,
|
|
deleteFromCollection = collection => fn => collection.delete(fn) ? stream : panic$2('Couldn\'t remove handler passed by reference');
|
|
|
|
return Object.assign(stream, {
|
|
on: Object.freeze({
|
|
value: addToCollection(success),
|
|
error: addToCollection(error),
|
|
end: addToCollection(end)
|
|
}),
|
|
off: Object.freeze({
|
|
value: deleteFromCollection(success),
|
|
error: deleteFromCollection(error),
|
|
end: deleteFromCollection(end)
|
|
}),
|
|
connect: addToCollection(modifiers),
|
|
|
|
push(input) {
|
|
const {
|
|
value,
|
|
done
|
|
} = stream.next(input); // dispatch the stream events
|
|
|
|
if (!done) {
|
|
value.then(res => dispatch(success, res), err => dispatch(error, err));
|
|
}
|
|
|
|
return stream;
|
|
},
|
|
|
|
end() {
|
|
// kill the stream
|
|
generator.return(); // dispatch the end event
|
|
|
|
dispatch(end) // clean up all the collections
|
|
;
|
|
[success, error, end, modifiers].forEach(el => el.clear());
|
|
return stream;
|
|
},
|
|
|
|
fork() {
|
|
return erre(...modifiers);
|
|
},
|
|
|
|
next(input) {
|
|
// get the input and run eventually the promise
|
|
const result = generator.next(input); // pause to the next iteration
|
|
|
|
generator.next();
|
|
return result;
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
const isNode = typeof process !== 'undefined';
|
|
|
|
const isString = str => typeof str === 'string'; // the url parsing function depends on the platform, on node we rely on the 'url' module
|
|
|
|
/* istanbul ignore next */
|
|
|
|
|
|
const parseURL = function parseURL() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return isNode ? require('url').parse(...args) : new URL(...args);
|
|
};
|
|
/**
|
|
* Replace the base path from a path
|
|
* @param {string} path - router path string
|
|
* @returns {string} path cleaned up without the base
|
|
*/
|
|
|
|
|
|
const replaceBase = path => path.replace(defaults.base, '');
|
|
/**
|
|
* Try to match the current path or skip it
|
|
* @param {RegEx} pathRegExp - target path transformed by pathToRegexp
|
|
* @returns {string|Symbol} if the path match we return it otherwise we cancel the stream
|
|
*/
|
|
|
|
|
|
const matchOrSkip = pathRegExp => path => match(path, pathRegExp) ? path : erre.cancel();
|
|
/**
|
|
* Combine 2 streams connecting the events of dispatcherStream to the receiverStream
|
|
* @param {Stream} dispatcherStream - main stream dispatching events
|
|
* @param {Stream} receiverStream - sub stream receiving events from the dispatcher
|
|
* @returns {Stream} receiverStream
|
|
*/
|
|
|
|
|
|
const joinStreams = (dispatcherStream, receiverStream) => {
|
|
dispatcherStream.on.value(receiverStream.push);
|
|
receiverStream.on.end(() => {
|
|
dispatcherStream.off.value(receiverStream.push);
|
|
});
|
|
return receiverStream;
|
|
};
|
|
/**
|
|
* Error handling function
|
|
* @param {Error} error - error to catch
|
|
* @returns {void}
|
|
*/
|
|
|
|
|
|
const panic$1 = error => {
|
|
if (defaults.silentErrors) return;
|
|
throw new Error(error);
|
|
}; // make sure that the router will always receive strings params
|
|
|
|
|
|
const filterStrings = str => isString(str) ? str : erre.cancel(); // create the streaming router
|
|
|
|
const router = erre(filterStrings).on.error(panic$1); // cast the values of this stream always to string
|
|
|
|
/* @type {object} general configuration object */
|
|
|
|
const defaults = {
|
|
// custom option
|
|
base: '',
|
|
silentErrors: false,
|
|
// pathToRegexp options
|
|
sensitive: false,
|
|
strict: false,
|
|
end: true,
|
|
start: true,
|
|
delimiter: '/#?',
|
|
encode: undefined,
|
|
endsWith: undefined,
|
|
prefixes: './'
|
|
};
|
|
/**
|
|
* Merge the user options with the defaults
|
|
* @param {Object} options - custom user options
|
|
* @returns {Object} options object merged with defaults
|
|
*/
|
|
|
|
const mergeOptions = options => Object.assign({}, defaults, options);
|
|
/* {@link https://github.com/pillarjs/path-to-regexp#usage} */
|
|
|
|
const toRegexp = (path, keys, options) => pathToRegexp(path, keys, mergeOptions(options));
|
|
/**
|
|
* Convert a router entry to a real path computing the url parameters
|
|
* @param {string} path - router path string
|
|
* @param {Object} params - named matched parameters
|
|
* @param {Object} options - pathToRegexp options object
|
|
* @returns {string} computed url string
|
|
*/
|
|
|
|
const toPath = (path, params, options) => compile(path, mergeOptions(options))(params);
|
|
/**
|
|
* Parse a string path generating an object containing
|
|
* @param {string} path - target path
|
|
* @param {RegExp} pathRegExp - path transformed to regexp via pathToRegexp
|
|
* @param {Object} options - object containing the base path
|
|
* @returns {URL} url object enhanced with the `match` attribute
|
|
*/
|
|
|
|
const toURL = function toURL(path, pathRegExp, options) {
|
|
if (options === void 0) {
|
|
options = {};
|
|
}
|
|
|
|
const {
|
|
base
|
|
} = mergeOptions(options);
|
|
const [, ...params] = pathRegExp.exec(path);
|
|
const url = parseURL(path, base); // extend the url object adding the matched params
|
|
|
|
url.params = params.reduce((acc, param, index) => {
|
|
const key = options.keys && options.keys[index];
|
|
if (key) acc[key.name] = param ? decodeURIComponent(param) : param;
|
|
return acc;
|
|
}, {});
|
|
return url;
|
|
};
|
|
/**
|
|
* Return true if a path will be matched
|
|
* @param {string} path - target path
|
|
* @param {RegExp} pathRegExp - path transformed to regexp via pathToRegexp
|
|
* @returns {boolean} true if the path matches the regexp
|
|
*/
|
|
|
|
const match = (path, pathRegExp) => pathRegExp.test(path);
|
|
/**
|
|
* Factory function to create an sequence of functions to pass to erre.js
|
|
* This function will be used in the erre stream
|
|
* @param {RegExp} pathRegExp - path transformed to regexp via pathToRegexp
|
|
* @param {Object} options - pathToRegexp options object
|
|
* @returns {Array} a functions array that will be used as stream pipe for erre.js
|
|
*/
|
|
|
|
const createURLStreamPipe = (pathRegExp, options) => [decodeURI, replaceBase, matchOrSkip(pathRegExp), path => toURL(path, pathRegExp, options)];
|
|
/**
|
|
* Create a fork of the main router stream
|
|
* @param {string} path - route to match
|
|
* @param {Object} options - pathToRegexp options object
|
|
* @returns {Stream} new route stream
|
|
*/
|
|
|
|
function createRoute(path, options) {
|
|
const keys = [];
|
|
const pathRegExp = pathToRegexp(path, keys, options);
|
|
const URLStream = erre(...createURLStreamPipe(pathRegExp, Object.assign({}, options, {
|
|
keys
|
|
})));
|
|
return joinStreams(router, URLStream).on.error(panic$1);
|
|
}
|
|
|
|
const getCurrentRoute = (currentRoute => {
|
|
// listen the route changes events to store the current route
|
|
router.on.value(r => currentRoute = r);
|
|
return () => {
|
|
return currentRoute;
|
|
};
|
|
})(null);
|
|
|
|
/**
|
|
* Similar to compose but performs from left-to-right function composition.<br/>
|
|
* {@link https://30secondsofcode.org/function#composeright see also}
|
|
* @param {...[function]} fns) - list of unary function
|
|
* @returns {*} result of the computation
|
|
*/
|
|
/**
|
|
* Performs right-to-left function composition.<br/>
|
|
* Use Array.prototype.reduce() to perform right-to-left function composition.<br/>
|
|
* The last (rightmost) function can accept one or more arguments; the remaining functions must be unary.<br/>
|
|
* {@link https://30secondsofcode.org/function#compose original source code}
|
|
* @param {...[function]} fns) - list of unary function
|
|
* @returns {*} result of the computation
|
|
*/
|
|
|
|
function compose() {
|
|
for (var _len2 = arguments.length, fns = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
fns[_key2] = arguments[_key2];
|
|
}
|
|
|
|
return fns.reduce((f, g) => function () {
|
|
return f(g(...arguments));
|
|
});
|
|
}
|
|
|
|
const getInitialRouteValue = (pathToRegexp, path, options) => {
|
|
const route = compose(
|
|
...createURLStreamPipe(pathToRegexp, options).reverse()
|
|
)(path);
|
|
|
|
return route.params ? route : null
|
|
};
|
|
|
|
var routeHoc = {
|
|
css: null,
|
|
|
|
exports: {
|
|
onBeforeMount(props) {
|
|
const currentRoute = getCurrentRoute();
|
|
const pathToRegexp = toRegexp(props.path, [], props);
|
|
|
|
this.state = {
|
|
pathToRegexp,
|
|
route: currentRoute && match(currentRoute, pathToRegexp) ?
|
|
getInitialRouteValue(pathToRegexp, currentRoute, props) :
|
|
null
|
|
};
|
|
|
|
router.on.value(this.onBeforeRoute);
|
|
this.stream = createRoute(props.path, props).on.value(this.onRoute);
|
|
},
|
|
|
|
onBeforeRoute(path, pathToRegexp) {
|
|
if (this.state.route && !match(path, this.state.pathToRegexp)) {
|
|
this.callLifecycleProperty('onBeforeUnmount', createRoute);
|
|
this.update({
|
|
route: null
|
|
});
|
|
this.callLifecycleProperty('onUnmounted', createRoute);
|
|
}
|
|
},
|
|
|
|
onRoute(route) {
|
|
this.callLifecycleProperty('onBeforeMount', route);
|
|
this.update({route});
|
|
this.callLifecycleProperty('onMounted', route);
|
|
},
|
|
|
|
callLifecycleProperty(method, ...params) {
|
|
if (this.props[method]) this.props[method](...params);
|
|
},
|
|
|
|
onUnmounted() {
|
|
router.off.value(this.onBeforeRoute);
|
|
this.stream.end();
|
|
}
|
|
},
|
|
|
|
template: (
|
|
template,
|
|
expressionTypes,
|
|
bindingTypes,
|
|
getComponent
|
|
) => template(
|
|
'<template expr0="expr0"></template>',
|
|
[
|
|
{
|
|
type: bindingTypes.IF,
|
|
evaluate: _scope => _scope.state.route,
|
|
redundantAttribute: 'expr0',
|
|
selector: '[expr0]',
|
|
|
|
template: template(
|
|
'<slot expr1="expr1"></slot>',
|
|
[
|
|
{
|
|
type: bindingTypes.SLOT,
|
|
|
|
attributes: [
|
|
{
|
|
type: expressionTypes.ATTRIBUTE,
|
|
name: 'route',
|
|
evaluate: _scope => _scope.state.route
|
|
}
|
|
],
|
|
|
|
name: 'default',
|
|
redundantAttribute: 'expr1',
|
|
selector: '[expr1]'
|
|
}
|
|
]
|
|
)
|
|
}
|
|
]
|
|
),
|
|
|
|
name: 'route-hoc'
|
|
};
|
|
|
|
const getGlobal = () => getWindow() || global;
|
|
const getWindow = () => typeof window === 'undefined' ? null : window;
|
|
const getDocument = () => typeof document === 'undefined' ? null : document;
|
|
const getHistory = () => typeof history === 'undefined' ? null : history;
|
|
const getLocation = () => {
|
|
const win = getWindow();
|
|
return win ? win.location : {};
|
|
};
|
|
const defer = (() => {
|
|
const globalScope = getGlobal();
|
|
return globalScope.requestAnimationFrame || globalScope.setTimeout;
|
|
})();
|
|
const cancelDefer = (() => {
|
|
const globalScope = getGlobal();
|
|
return globalScope.cancelAnimationFrame || globalScope.clearTimeout;
|
|
})();
|
|
|
|
const WINDOW_EVENTS = 'popstate';
|
|
const CLICK_EVENT = 'click';
|
|
const DOWNLOAD_LINK_ATTRIBUTE = 'download';
|
|
const HREF_LINK_ATTRIBUTE = 'href';
|
|
const TARGET_SELF_LINK_ATTRIBUTE = '_self';
|
|
const LINK_TAG_NAME = 'A';
|
|
const HASH = '#';
|
|
const SLASH = '/';
|
|
const RE_ORIGIN = /^.+?\/\/+[^/]+/;
|
|
|
|
const normalizeInitialSlash = str => str[0] === SLASH ? str : `${SLASH}${str}`;
|
|
const removeTrailingSlash = str => str[str.length - 1] === SLASH ? str.substr(0, str.length - 1) : str;
|
|
const normalizeBase = base => {
|
|
const win = getWindow();
|
|
const loc = win.location;
|
|
const root = loc ? `${loc.protocol}//${loc.host}` : '';
|
|
const {
|
|
pathname
|
|
} = loc ? loc : {};
|
|
|
|
switch (true) {
|
|
// pure root url + pathname
|
|
case Boolean(base) === false:
|
|
return removeTrailingSlash(`${root}${pathname || ''}`);
|
|
// full path base
|
|
|
|
case /(www|http(s)?:)/.test(base):
|
|
return base;
|
|
// hash navigation
|
|
|
|
case base[0] === HASH:
|
|
return `${root}${pathname && pathname !== SLASH ? pathname : ''}${base}`;
|
|
// root url with trailing slash
|
|
|
|
case base === SLASH:
|
|
return removeTrailingSlash(root);
|
|
// custom pathname
|
|
|
|
default:
|
|
return removeTrailingSlash(`${root}${normalizeInitialSlash(base)}`);
|
|
}
|
|
};
|
|
function setBase(base) {
|
|
defaults.base = normalizeBase(base);
|
|
}
|
|
|
|
/**
|
|
* Convert a string from camel case to dash-case
|
|
* @param {string} string - probably a component tag name
|
|
* @returns {string} component name normalized
|
|
*/
|
|
/**
|
|
* Convert a string containing dashes to camel case
|
|
* @param {string} string - input string
|
|
* @returns {string} my-string -> myString
|
|
*/
|
|
|
|
function dashToCamelCase(string) {
|
|
return string.replace(/-(\w)/g, (_, c) => c.toUpperCase());
|
|
}
|
|
|
|
/**
|
|
* Throw an error with a descriptive message
|
|
* @param { string } message - error message
|
|
* @returns { undefined } hoppla.. at this point the program should stop working
|
|
*/
|
|
|
|
function panic(message) {
|
|
throw new Error(message);
|
|
}
|
|
|
|
/**
|
|
* Converts any DOM node/s to a loopable array
|
|
* @param { HTMLElement|NodeList } els - single html element or a node list
|
|
* @returns { Array } always a loopable object
|
|
*/
|
|
function domToArray(els) {
|
|
// can this object be already looped?
|
|
if (!Array.isArray(els)) {
|
|
// is it a node list?
|
|
if (/^\[object (HTMLCollection|NodeList|Object)\]$/.test(Object.prototype.toString.call(els)) && typeof els.length === 'number') return Array.from(els);else // if it's a single node
|
|
// it will be returned as "array" with one single entry
|
|
return [els];
|
|
} // this object could be looped out of the box
|
|
|
|
|
|
return els;
|
|
}
|
|
|
|
/**
|
|
* Split a string into several items separed by spaces
|
|
* @param { string } l - events list
|
|
* @returns { Array } all the events detected
|
|
* @private
|
|
*/
|
|
|
|
const split = l => l.split(/\s/);
|
|
/**
|
|
* Set a listener for all the events received separated by spaces
|
|
* @param { HTMLElement|NodeList|Array } els - DOM node/s where the listeners will be bound
|
|
* @param { string } evList - list of events we want to bind or unbind space separated
|
|
* @param { Function } cb - listeners callback
|
|
* @param { string } method - either 'addEventListener' or 'removeEventListener'
|
|
* @param { Object } options - event options (capture, once and passive)
|
|
* @returns { undefined }
|
|
* @private
|
|
*/
|
|
|
|
|
|
function manageEvents(els, evList, cb, method, options) {
|
|
els = domToArray(els);
|
|
split(evList).forEach(e => {
|
|
els.forEach(el => el[method](e, cb, options || false));
|
|
});
|
|
}
|
|
/**
|
|
* Set a listener for all the events received separated by spaces
|
|
* @param { HTMLElement|Array } els - DOM node/s where the listeners will be bound
|
|
* @param { string } evList - list of events we want to bind space separated
|
|
* @param { Function } cb - listeners callback
|
|
* @param { Object } options - event options (capture, once and passive)
|
|
* @returns { HTMLElement|NodeList|Array } DOM node/s and first argument of the function
|
|
*/
|
|
|
|
|
|
function add(els, evList, cb, options) {
|
|
manageEvents(els, evList, cb, 'addEventListener', options);
|
|
return els;
|
|
}
|
|
/**
|
|
* Remove all the listeners for the events received separated by spaces
|
|
* @param { HTMLElement|Array } els - DOM node/s where the events will be unbind
|
|
* @param { string } evList - list of events we want unbind space separated
|
|
* @param { Function } cb - listeners callback
|
|
* @param { Object } options - event options (capture, once and passive)
|
|
* @returns { HTMLElement|NodeList|Array } DOM node/s and first argument of the function
|
|
*/
|
|
|
|
function remove(els, evList, cb, options) {
|
|
manageEvents(els, evList, cb, 'removeEventListener', options);
|
|
return els;
|
|
}
|
|
|
|
/**
|
|
* Normalize the return values, in case of a single value we avoid to return an array
|
|
* @param { Array } values - list of values we want to return
|
|
* @returns { Array|string|boolean } either the whole list of values or the single one found
|
|
* @private
|
|
*/
|
|
|
|
const normalize = values => values.length === 1 ? values[0] : values;
|
|
/**
|
|
* Parse all the nodes received to get/remove/check their attributes
|
|
* @param { HTMLElement|NodeList|Array } els - DOM node/s to parse
|
|
* @param { string|Array } name - name or list of attributes
|
|
* @param { string } method - method that will be used to parse the attributes
|
|
* @returns { Array|string } result of the parsing in a list or a single value
|
|
* @private
|
|
*/
|
|
|
|
|
|
function parseNodes(els, name, method) {
|
|
const names = typeof name === 'string' ? [name] : name;
|
|
return normalize(domToArray(els).map(el => {
|
|
return normalize(names.map(n => el[method](n)));
|
|
}));
|
|
}
|
|
/**
|
|
* Set any attribute on a single or a list of DOM nodes
|
|
* @param { HTMLElement|NodeList|Array } els - DOM node/s to parse
|
|
* @param { string|Array } name - name or list of attributes to detect
|
|
* @returns { boolean|Array } true or false or an array of boolean values
|
|
* @example
|
|
*
|
|
* import { has } from 'bianco.attr'
|
|
*
|
|
* has(img, 'width') // false
|
|
*
|
|
* // or also
|
|
* has(img, ['width', 'height']) // => [false, false]
|
|
*
|
|
* // or also
|
|
* has([img1, img2], ['width', 'height']) // => [[false, false], [false, false]]
|
|
*/
|
|
|
|
function has(els, name) {
|
|
return parseNodes(els, name, 'hasAttribute');
|
|
}
|
|
|
|
const onWindowEvent = () => router.push(normalizePath(String(getLocation().href)));
|
|
|
|
const onRouterPush = path => {
|
|
const url = path.includes(defaults.base) ? path : defaults.base + path;
|
|
const loc = getLocation();
|
|
const hist = getHistory();
|
|
const doc = getDocument(); // update the browser history only if it's necessary
|
|
|
|
if (hist && url !== loc.href) {
|
|
hist.pushState(null, doc.title, url);
|
|
}
|
|
};
|
|
|
|
const getLinkElement = node => node && !isLinkNode(node) ? getLinkElement(node.parentNode) : node;
|
|
|
|
const isLinkNode = node => node.nodeName === LINK_TAG_NAME;
|
|
|
|
const isCrossOriginLink = path => path.indexOf(getLocation().href.match(RE_ORIGIN)[0]) === -1;
|
|
|
|
const isTargetSelfLink = el => el.target && el.target !== TARGET_SELF_LINK_ATTRIBUTE;
|
|
|
|
const isEventForbidden = event => event.which && event.which !== 1 // not left click
|
|
|| event.metaKey || event.ctrlKey || event.shiftKey // or meta keys
|
|
|| event.defaultPrevented; // or default prevented
|
|
|
|
|
|
const isForbiddenLink = el => !el || !isLinkNode(el) // not A tag
|
|
|| has(el, DOWNLOAD_LINK_ATTRIBUTE) // has download attr
|
|
|| !has(el, HREF_LINK_ATTRIBUTE) // has no href attr
|
|
|| isTargetSelfLink(el) || isCrossOriginLink(el.href);
|
|
|
|
const isHashLink = path => path.split(HASH).length > 1;
|
|
|
|
const normalizePath = path => path.replace(defaults.base, '');
|
|
|
|
const isInBase = path => !defaults.base || path.includes(defaults.base);
|
|
/**
|
|
* Callback called anytime something will be clicked on the page
|
|
* @param {HTMLEvent} event - click event
|
|
* @returns {undefined} void method
|
|
*/
|
|
|
|
|
|
const onClick = event => {
|
|
if (isEventForbidden(event)) return;
|
|
const el = getLinkElement(event.target);
|
|
if (isForbiddenLink(el) || isHashLink(el.href) || !isInBase(el.href)) return;
|
|
const path = normalizePath(el.href);
|
|
router.push(path);
|
|
event.preventDefault();
|
|
};
|
|
/**
|
|
* Link the rawth router to the DOM events
|
|
* @param { HTMLElement } container - DOM node where the links are located
|
|
* @returns {Function} teardown function
|
|
*/
|
|
|
|
|
|
function initDomListeners(container) {
|
|
const win = getWindow();
|
|
const root = container || getDocument();
|
|
|
|
if (win) {
|
|
add(win, WINDOW_EVENTS, onWindowEvent);
|
|
add(root, CLICK_EVENT, onClick);
|
|
}
|
|
|
|
router.on.value(onRouterPush);
|
|
return () => {
|
|
if (win) {
|
|
remove(win, WINDOW_EVENTS, onWindowEvent);
|
|
remove(root, CLICK_EVENT, onClick);
|
|
}
|
|
|
|
router.off.value(onRouterPush);
|
|
};
|
|
}
|
|
|
|
const BASE_ATTRIBUTE_NAME = 'base';
|
|
const INITIAL_ROUTE = 'initialRoute';
|
|
const ON_STARTED_ATTRIBUTE_NAME = 'onStarted';
|
|
const {template, bindingTypes} = __.DOMBindings;
|
|
|
|
|
|
let wasInitialized = false;
|
|
|
|
var routerHoc = {
|
|
css: null,
|
|
|
|
exports: pure(
|
|
({slots, attributes, props}) => {
|
|
if (wasInitialized) panic('Multiple <router> components are not supported');
|
|
|
|
const getAttribute = name => attributes && attributes.find(a => dashToCamelCase(a.name) === name);
|
|
|
|
return {
|
|
slot: null,
|
|
el: null,
|
|
teardown: null,
|
|
mount(el, context) {
|
|
const initialRouteAttr = getAttribute(INITIAL_ROUTE);
|
|
const initialRoute = initialRouteAttr ? initialRouteAttr.evaluate(context) : null;
|
|
const currentRoute = getCurrentRoute();
|
|
const onFirstRoute = () => {
|
|
this.createSlot(context);
|
|
router.off.value(onFirstRoute);
|
|
};
|
|
wasInitialized = true;
|
|
|
|
this.el = el;
|
|
this.teardown = initDomListeners(this.root);
|
|
|
|
this.setBase(context);
|
|
|
|
// mount the slots only if the current route was defined
|
|
if (currentRoute && !initialRoute) {
|
|
this.createSlot(context);
|
|
} else {
|
|
router.on.value(onFirstRoute);
|
|
router.push(initialRoute || window.location.href);
|
|
}
|
|
},
|
|
createSlot(context) {
|
|
if (!slots || !slots.length) return
|
|
const onStartedAttr = getAttribute(ON_STARTED_ATTRIBUTE_NAME);
|
|
|
|
this.slot = template(null, [{
|
|
type: bindingTypes.SLOT,
|
|
name: 'default'
|
|
}]);
|
|
|
|
this.slot.mount(this.el, {
|
|
slots
|
|
}, context);
|
|
|
|
if (onStartedAttr) {
|
|
onStartedAttr.evaluate(context)(getCurrentRoute());
|
|
}
|
|
},
|
|
update(context) {
|
|
this.setBase(context);
|
|
|
|
// defer the updates to avoid internal recursive update calls
|
|
// see https://github.com/riot/route/issues/148
|
|
if (this.slot) {
|
|
cancelDefer(this.deferred);
|
|
|
|
this.deferred = defer(() => {
|
|
this.slot.update({}, context);
|
|
});
|
|
}
|
|
},
|
|
unmount(...args) {
|
|
this.teardown();
|
|
wasInitialized = false;
|
|
|
|
if (this.slot) {
|
|
this.slot.unmount(...args);
|
|
}
|
|
},
|
|
getBase(context) {
|
|
const baseAttr = getAttribute(BASE_ATTRIBUTE_NAME);
|
|
|
|
return baseAttr ? this.el.getAttribute(BASE_ATTRIBUTE_NAME) || baseAttr.evaluate(context) : '/'
|
|
},
|
|
setBase(context) {
|
|
setBase(props ? props.base : this.getBase(context));
|
|
}
|
|
}
|
|
}
|
|
),
|
|
|
|
template: null,
|
|
name: 'router-hoc'
|
|
};
|
|
|
|
export { routeHoc as Route, routerHoc as Router, createURLStreamPipe, filterStrings, getCurrentRoute, initDomListeners, match, createRoute as route, router, setBase, toPath, toRegexp, toURL };
|