2015-07-10 13:37:13 +00:00
|
|
|
/*
|
2016-01-07 04:06:39 +00:00
|
|
|
Copyright 2015, 2016 OpenMarket Ltd
|
2019-10-01 02:17:54 +00:00
|
|
|
Copyright 2019 The Matrix.org Foundation C.I.C.
|
2015-07-10 13:37:13 +00:00
|
|
|
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
you may not use this file except in compliance with the License.
|
|
|
|
You may obtain a copy of the License at
|
|
|
|
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
See the License for the specific language governing permissions and
|
|
|
|
limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2019-09-30 18:51:17 +00:00
|
|
|
import {baseUrl} from "./utils/permalinks/SpecPermalinkConstructor";
|
2020-03-20 00:42:44 +00:00
|
|
|
import {
|
|
|
|
parsePermalink,
|
|
|
|
tryTransformEntityToPermalink,
|
|
|
|
tryTransformPermalinkToLocalHref
|
|
|
|
} from "./utils/permalinks/Permalinks";
|
2017-12-10 12:50:41 +00:00
|
|
|
|
2015-07-10 13:37:13 +00:00
|
|
|
function matrixLinkify(linkify) {
|
|
|
|
// Text tokens
|
2017-10-11 16:56:17 +00:00
|
|
|
const TT = linkify.scanner.TOKENS;
|
2015-07-10 13:37:13 +00:00
|
|
|
// Multi tokens
|
2017-10-11 16:56:17 +00:00
|
|
|
const MT = linkify.parser.TOKENS;
|
|
|
|
const MultiToken = MT.Base;
|
|
|
|
const S_START = linkify.parser.start;
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2016-09-27 09:38:01 +00:00
|
|
|
if (TT.UNDERSCORE === undefined) {
|
|
|
|
throw new Error("linkify-matrix requires linkifyjs 2.1.1: this version is too old.");
|
|
|
|
}
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2017-10-11 16:56:17 +00:00
|
|
|
const ROOMALIAS = function(value) {
|
2016-09-13 18:36:46 +00:00
|
|
|
MultiToken.call(this, value);
|
|
|
|
this.type = 'roomalias';
|
|
|
|
this.isLink = true;
|
|
|
|
};
|
|
|
|
ROOMALIAS.prototype = new MultiToken();
|
|
|
|
|
2018-06-26 22:36:01 +00:00
|
|
|
const S_HASH = S_START.jump(TT.POUND);
|
2017-10-11 16:56:17 +00:00
|
|
|
const S_HASH_NAME = new linkify.parser.State();
|
|
|
|
const S_HASH_NAME_COLON = new linkify.parser.State();
|
|
|
|
const S_HASH_NAME_COLON_DOMAIN = new linkify.parser.State();
|
|
|
|
const S_HASH_NAME_COLON_DOMAIN_DOT = new linkify.parser.State();
|
|
|
|
const S_ROOMALIAS = new linkify.parser.State(ROOMALIAS);
|
2018-06-26 22:33:35 +00:00
|
|
|
const S_ROOMALIAS_COLON = new linkify.parser.State();
|
2018-06-26 22:41:46 +00:00
|
|
|
const S_ROOMALIAS_COLON_NUM = new linkify.parser.State(ROOMALIAS);
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
const roomnameTokens = [
|
2015-07-10 13:37:13 +00:00
|
|
|
TT.DOT,
|
|
|
|
TT.PLUS,
|
|
|
|
TT.NUM,
|
|
|
|
TT.DOMAIN,
|
2016-09-21 13:11:43 +00:00
|
|
|
TT.TLD,
|
|
|
|
TT.UNDERSCORE,
|
|
|
|
TT.POUND,
|
2016-09-23 13:02:14 +00:00
|
|
|
|
|
|
|
// because 'localhost' is tokenised to the localhost token,
|
|
|
|
// usernames @localhost:foo.com are otherwise not matched!
|
|
|
|
TT.LOCALHOST,
|
2015-07-10 13:37:13 +00:00
|
|
|
];
|
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
S_HASH.on(roomnameTokens, S_HASH_NAME);
|
|
|
|
S_HASH_NAME.on(roomnameTokens, S_HASH_NAME);
|
2016-09-13 18:36:46 +00:00
|
|
|
S_HASH_NAME.on(TT.DOMAIN, S_HASH_NAME);
|
2015-07-10 13:37:13 +00:00
|
|
|
|
|
|
|
S_HASH_NAME.on(TT.COLON, S_HASH_NAME_COLON);
|
|
|
|
|
2016-09-13 18:36:46 +00:00
|
|
|
S_HASH_NAME_COLON.on(TT.DOMAIN, S_HASH_NAME_COLON_DOMAIN);
|
2016-09-23 13:02:14 +00:00
|
|
|
S_HASH_NAME_COLON.on(TT.LOCALHOST, S_ROOMALIAS); // accept #foo:localhost
|
2018-06-23 18:42:03 +00:00
|
|
|
S_HASH_NAME_COLON.on(TT.TLD, S_ROOMALIAS); // accept #foo:com (mostly for (TLD|DOMAIN)+ mixing)
|
2016-09-13 18:36:46 +00:00
|
|
|
S_HASH_NAME_COLON_DOMAIN.on(TT.DOT, S_HASH_NAME_COLON_DOMAIN_DOT);
|
|
|
|
S_HASH_NAME_COLON_DOMAIN_DOT.on(TT.DOMAIN, S_HASH_NAME_COLON_DOMAIN);
|
|
|
|
S_HASH_NAME_COLON_DOMAIN_DOT.on(TT.TLD, S_ROOMALIAS);
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2018-06-23 18:28:48 +00:00
|
|
|
S_ROOMALIAS.on(TT.DOT, S_HASH_NAME_COLON_DOMAIN_DOT); // accept repeated TLDs (e.g .org.uk)
|
2018-06-26 22:33:35 +00:00
|
|
|
S_ROOMALIAS.on(TT.COLON, S_ROOMALIAS_COLON); // do not accept trailing `:`
|
2018-06-26 22:41:46 +00:00
|
|
|
S_ROOMALIAS_COLON.on(TT.NUM, S_ROOMALIAS_COLON_NUM); // but do accept :NUM (port specifier)
|
2018-06-23 18:28:48 +00:00
|
|
|
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2017-10-11 16:56:17 +00:00
|
|
|
const USERID = function(value) {
|
2016-09-13 18:36:46 +00:00
|
|
|
MultiToken.call(this, value);
|
|
|
|
this.type = 'userid';
|
|
|
|
this.isLink = true;
|
2015-07-10 13:37:13 +00:00
|
|
|
};
|
2016-09-13 18:36:46 +00:00
|
|
|
USERID.prototype = new MultiToken();
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2018-06-26 22:36:01 +00:00
|
|
|
const S_AT = S_START.jump(TT.AT);
|
2017-10-11 16:56:17 +00:00
|
|
|
const S_AT_NAME = new linkify.parser.State();
|
|
|
|
const S_AT_NAME_COLON = new linkify.parser.State();
|
|
|
|
const S_AT_NAME_COLON_DOMAIN = new linkify.parser.State();
|
|
|
|
const S_AT_NAME_COLON_DOMAIN_DOT = new linkify.parser.State();
|
|
|
|
const S_USERID = new linkify.parser.State(USERID);
|
2018-06-26 22:33:35 +00:00
|
|
|
const S_USERID_COLON = new linkify.parser.State();
|
2018-06-26 22:41:46 +00:00
|
|
|
const S_USERID_COLON_NUM = new linkify.parser.State(USERID);
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
const usernameTokens = [
|
2015-07-10 13:37:13 +00:00
|
|
|
TT.DOT,
|
2016-09-23 13:02:14 +00:00
|
|
|
TT.UNDERSCORE,
|
2015-07-10 13:37:13 +00:00
|
|
|
TT.PLUS,
|
|
|
|
TT.NUM,
|
|
|
|
TT.DOMAIN,
|
2016-09-23 13:02:14 +00:00
|
|
|
TT.TLD,
|
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
// as in roomnameTokens
|
2016-09-23 13:02:14 +00:00
|
|
|
TT.LOCALHOST,
|
2015-07-10 13:37:13 +00:00
|
|
|
];
|
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
S_AT.on(usernameTokens, S_AT_NAME);
|
|
|
|
S_AT_NAME.on(usernameTokens, S_AT_NAME);
|
2016-09-13 18:36:46 +00:00
|
|
|
S_AT_NAME.on(TT.DOMAIN, S_AT_NAME);
|
2015-07-10 13:37:13 +00:00
|
|
|
|
|
|
|
S_AT_NAME.on(TT.COLON, S_AT_NAME_COLON);
|
|
|
|
|
2016-09-13 18:36:46 +00:00
|
|
|
S_AT_NAME_COLON.on(TT.DOMAIN, S_AT_NAME_COLON_DOMAIN);
|
2016-09-23 13:02:14 +00:00
|
|
|
S_AT_NAME_COLON.on(TT.LOCALHOST, S_USERID); // accept @foo:localhost
|
2018-06-23 18:42:03 +00:00
|
|
|
S_AT_NAME_COLON.on(TT.TLD, S_USERID); // accept @foo:com (mostly for (TLD|DOMAIN)+ mixing)
|
2016-09-13 18:36:46 +00:00
|
|
|
S_AT_NAME_COLON_DOMAIN.on(TT.DOT, S_AT_NAME_COLON_DOMAIN_DOT);
|
|
|
|
S_AT_NAME_COLON_DOMAIN_DOT.on(TT.DOMAIN, S_AT_NAME_COLON_DOMAIN);
|
|
|
|
S_AT_NAME_COLON_DOMAIN_DOT.on(TT.TLD, S_USERID);
|
2017-06-05 15:51:50 +00:00
|
|
|
|
2018-06-23 18:28:48 +00:00
|
|
|
S_USERID.on(TT.DOT, S_AT_NAME_COLON_DOMAIN_DOT); // accept repeated TLDs (e.g .org.uk)
|
2018-06-26 22:33:35 +00:00
|
|
|
S_USERID.on(TT.COLON, S_USERID_COLON); // do not accept trailing `:`
|
2018-06-26 22:41:46 +00:00
|
|
|
S_USERID_COLON.on(TT.NUM, S_USERID_COLON_NUM); // but do accept :NUM (port specifier)
|
2018-06-23 18:28:48 +00:00
|
|
|
|
2017-06-05 15:51:50 +00:00
|
|
|
|
2017-10-11 16:56:17 +00:00
|
|
|
const GROUPID = function(value) {
|
2017-06-05 15:51:50 +00:00
|
|
|
MultiToken.call(this, value);
|
|
|
|
this.type = 'groupid';
|
|
|
|
this.isLink = true;
|
|
|
|
};
|
|
|
|
GROUPID.prototype = new MultiToken();
|
|
|
|
|
2018-06-26 22:36:01 +00:00
|
|
|
const S_PLUS = S_START.jump(TT.PLUS);
|
2017-10-11 16:56:17 +00:00
|
|
|
const S_PLUS_NAME = new linkify.parser.State();
|
|
|
|
const S_PLUS_NAME_COLON = new linkify.parser.State();
|
|
|
|
const S_PLUS_NAME_COLON_DOMAIN = new linkify.parser.State();
|
|
|
|
const S_PLUS_NAME_COLON_DOMAIN_DOT = new linkify.parser.State();
|
|
|
|
const S_GROUPID = new linkify.parser.State(GROUPID);
|
2018-06-26 22:33:35 +00:00
|
|
|
const S_GROUPID_COLON = new linkify.parser.State();
|
2018-06-26 22:41:46 +00:00
|
|
|
const S_GROUPID_COLON_NUM = new linkify.parser.State(GROUPID);
|
2017-06-05 15:51:50 +00:00
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
const groupIdTokens = [
|
2017-06-05 15:51:50 +00:00
|
|
|
TT.DOT,
|
|
|
|
TT.UNDERSCORE,
|
|
|
|
TT.PLUS,
|
|
|
|
TT.NUM,
|
|
|
|
TT.DOMAIN,
|
|
|
|
TT.TLD,
|
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
// as in roomnameTokens
|
2017-06-05 15:51:50 +00:00
|
|
|
TT.LOCALHOST,
|
|
|
|
];
|
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
S_PLUS.on(groupIdTokens, S_PLUS_NAME);
|
|
|
|
S_PLUS_NAME.on(groupIdTokens, S_PLUS_NAME);
|
2017-06-05 15:51:50 +00:00
|
|
|
S_PLUS_NAME.on(TT.DOMAIN, S_PLUS_NAME);
|
|
|
|
|
|
|
|
S_PLUS_NAME.on(TT.COLON, S_PLUS_NAME_COLON);
|
|
|
|
|
|
|
|
S_PLUS_NAME_COLON.on(TT.DOMAIN, S_PLUS_NAME_COLON_DOMAIN);
|
|
|
|
S_PLUS_NAME_COLON.on(TT.LOCALHOST, S_GROUPID); // accept +foo:localhost
|
2018-06-23 18:42:03 +00:00
|
|
|
S_PLUS_NAME_COLON.on(TT.TLD, S_GROUPID); // accept +foo:com (mostly for (TLD|DOMAIN)+ mixing)
|
2017-06-05 15:51:50 +00:00
|
|
|
S_PLUS_NAME_COLON_DOMAIN.on(TT.DOT, S_PLUS_NAME_COLON_DOMAIN_DOT);
|
|
|
|
S_PLUS_NAME_COLON_DOMAIN_DOT.on(TT.DOMAIN, S_PLUS_NAME_COLON_DOMAIN);
|
|
|
|
S_PLUS_NAME_COLON_DOMAIN_DOT.on(TT.TLD, S_GROUPID);
|
2018-06-23 18:28:48 +00:00
|
|
|
|
|
|
|
S_GROUPID.on(TT.DOT, S_PLUS_NAME_COLON_DOMAIN_DOT); // accept repeated TLDs (e.g .org.uk)
|
2018-06-26 22:33:35 +00:00
|
|
|
S_GROUPID.on(TT.COLON, S_GROUPID_COLON); // do not accept trailing `:`
|
2018-06-26 22:41:46 +00:00
|
|
|
S_GROUPID_COLON.on(TT.NUM, S_GROUPID_COLON_NUM); // but do accept :NUM (port specifier)
|
2015-07-10 13:37:13 +00:00
|
|
|
}
|
|
|
|
|
2016-08-28 00:55:42 +00:00
|
|
|
// stubs, overwritten in MatrixChat's componentDidMount
|
2016-08-28 01:05:23 +00:00
|
|
|
matrixLinkify.onUserClick = function(e, userId) { e.preventDefault(); };
|
|
|
|
matrixLinkify.onAliasClick = function(e, roomAlias) { e.preventDefault(); };
|
2017-06-05 15:51:50 +00:00
|
|
|
matrixLinkify.onGroupClick = function(e, groupId) { e.preventDefault(); };
|
2015-10-26 17:59:49 +00:00
|
|
|
|
2017-10-11 16:56:17 +00:00
|
|
|
const escapeRegExp = function(string) {
|
2016-03-20 12:31:30 +00:00
|
|
|
return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
|
|
|
|
};
|
|
|
|
|
2016-08-28 00:55:42 +00:00
|
|
|
// Recognise URLs from both our local vector and official vector as vector.
|
|
|
|
// anyone else really should be using matrix.to.
|
2019-09-18 08:27:43 +00:00
|
|
|
matrixLinkify.VECTOR_URL_PATTERN = "^(?:https?://)?(?:"
|
2016-08-28 00:55:42 +00:00
|
|
|
+ escapeRegExp(window.location.host + window.location.pathname) + "|"
|
2017-04-22 20:06:38 +00:00
|
|
|
+ "(?:www\\.)?(?:riot|vector)\\.im/(?:app|beta|staging|develop)/"
|
2016-08-28 00:55:42 +00:00
|
|
|
+ ")(#.*)";
|
|
|
|
|
2019-09-18 08:27:43 +00:00
|
|
|
matrixLinkify.MATRIXTO_URL_PATTERN = "^(?:https?://)?(?:www\\.)?matrix\\.to/#/(([#@!+]).*)";
|
2017-07-21 15:38:31 +00:00
|
|
|
matrixLinkify.MATRIXTO_MD_LINK_PATTERN =
|
2019-09-18 08:27:43 +00:00
|
|
|
'\\[([^\\]]*)\\]\\((?:https?://)?(?:www\\.)?matrix\\.to/#/([#@!+][^\\)]*)\\)';
|
2017-12-10 12:50:41 +00:00
|
|
|
matrixLinkify.MATRIXTO_BASE_URL= baseUrl;
|
2016-03-20 03:05:07 +00:00
|
|
|
|
2015-07-10 13:37:13 +00:00
|
|
|
matrixLinkify.options = {
|
2017-01-20 14:22:27 +00:00
|
|
|
events: function(href, type) {
|
2015-07-10 13:37:13 +00:00
|
|
|
switch (type) {
|
2020-03-20 00:42:44 +00:00
|
|
|
case "url": {
|
|
|
|
// intercept local permalinks to users and show them like userids (in userinfo of current room)
|
|
|
|
const permalink = parsePermalink(href);
|
|
|
|
if (permalink && permalink.userId) {
|
|
|
|
return {
|
|
|
|
click: function(e) {
|
|
|
|
matrixLinkify.onUserClick(e, permalink.userId);
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2015-10-27 09:58:55 +00:00
|
|
|
case "userid":
|
|
|
|
return {
|
|
|
|
click: function(e) {
|
|
|
|
matrixLinkify.onUserClick(e, href);
|
2017-10-11 16:56:17 +00:00
|
|
|
},
|
2015-10-27 09:58:55 +00:00
|
|
|
};
|
|
|
|
case "roomalias":
|
|
|
|
return {
|
|
|
|
click: function(e) {
|
|
|
|
matrixLinkify.onAliasClick(e, href);
|
2017-10-11 16:56:17 +00:00
|
|
|
},
|
2015-10-27 09:58:55 +00:00
|
|
|
};
|
2017-06-05 15:51:50 +00:00
|
|
|
case "groupid":
|
|
|
|
return {
|
|
|
|
click: function(e) {
|
|
|
|
matrixLinkify.onGroupClick(e, href);
|
2017-10-11 16:56:17 +00:00
|
|
|
},
|
2017-06-05 15:51:50 +00:00
|
|
|
};
|
2015-07-10 13:37:13 +00:00
|
|
|
}
|
2016-02-18 18:16:39 +00:00
|
|
|
},
|
2016-08-28 01:05:23 +00:00
|
|
|
|
2017-01-20 14:22:27 +00:00
|
|
|
formatHref: function(href, type) {
|
2016-02-18 18:16:39 +00:00
|
|
|
switch (type) {
|
2016-03-20 03:05:07 +00:00
|
|
|
case 'roomalias':
|
|
|
|
case 'userid':
|
2017-06-27 12:37:59 +00:00
|
|
|
case 'groupid':
|
2018-06-16 07:27:17 +00:00
|
|
|
default: {
|
2020-03-04 20:56:58 +00:00
|
|
|
return tryTransformEntityToPermalink(href);
|
2018-06-16 07:27:17 +00:00
|
|
|
}
|
2016-03-20 03:05:07 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2016-08-15 20:37:26 +00:00
|
|
|
linkAttributes: {
|
2020-02-23 22:14:29 +00:00
|
|
|
rel: 'noreferrer noopener',
|
2016-08-15 20:37:26 +00:00
|
|
|
},
|
|
|
|
|
2016-03-20 03:05:07 +00:00
|
|
|
target: function(href, type) {
|
|
|
|
if (type === 'url') {
|
2019-10-01 02:17:54 +00:00
|
|
|
const transformed = tryTransformPermalinkToLocalHref(href);
|
|
|
|
if (transformed !== href || href.match(matrixLinkify.VECTOR_URL_PATTERN)) {
|
2016-03-20 03:05:07 +00:00
|
|
|
return null;
|
2017-10-11 16:56:17 +00:00
|
|
|
} else {
|
2016-03-20 03:05:07 +00:00
|
|
|
return '_blank';
|
|
|
|
}
|
|
|
|
}
|
2016-03-21 15:45:04 +00:00
|
|
|
return null;
|
2016-03-20 03:05:07 +00:00
|
|
|
},
|
2015-10-26 17:59:49 +00:00
|
|
|
};
|
2015-07-10 13:37:13 +00:00
|
|
|
|
2019-11-06 09:41:14 +00:00
|
|
|
export default matrixLinkify;
|