kopia lustrzana https://github.com/lartsch/FediAct
1616 wiersze
59 KiB
JavaScript
1616 wiersze
59 KiB
JavaScript
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=
|
|
// =-=-=-=-=-= CONSTANTS =-==-=-=-=
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=
|
|
|
|
const followButtonPaths = ["div.account__header button.logo-button","div.public-account-header a.logo-button","div.account-card a.logo-button","div.directory-card a.icon-button", "div.directory__card a.icon-button", "div.detailed-status a.logo-button", "button.remote-button", "div.account__header button.button--follow"]
|
|
const profileNamePaths = ["div.account__header__tabs__name small", "div.public-account-header__tabs__name small", "div.detailed-status span.display-name__account", "div.display-name > span", "a.user-screen-name", "div.profile-info-panel small"]
|
|
const domainRegex = /^([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}$/
|
|
const handleExtractUrlRegex = /^(?<domain>https?:\/\/(?:\.?[a-z0-9-]+)+(?:\.[a-z]+){1})?\/?@(?<handle>\w+)(?:@(?<handledomain>(?:[\w-]+\.)+?\w+))?(?:\/(?<tootid>\d+))?\/?$/
|
|
const handleExtractUriRegex = /^(?<domain>https?:\/\/(?:\.?[a-z0-9-]+)+(?:\.[a-z]+){1})(?:\/users\/)(?<handle>\w+)(?:(?:\/statuses\/)(?<tootid>\d+))?\/?$/
|
|
const enableConsoleLog = false
|
|
const logPrepend = "[FediAct]"
|
|
const instanceApi = "/api/v1/instance"
|
|
const statusApi = "/api/v1/statuses"
|
|
const searchApi = "/api/v2/search"
|
|
const accountsApi = "/api/v1/accounts"
|
|
const mutesApi = "/api/v1/mutes"
|
|
const blocksApi = "/api/v1/blocks"
|
|
const domainBlocksApi = "/api/v1/domain_blocks"
|
|
const pollsApi = "/api/v1/polls"
|
|
const apiDelay = 600
|
|
const maxTootCache = 200
|
|
const modalHtml = '<div class="fediactmodal"><div class="fediactmodalinner"><ul class="fediactmodallist"></ul></div></div>'
|
|
const maxAsyncRequests = 10
|
|
|
|
// settings keys with defauls
|
|
var settings = {}
|
|
const settingsDefaults = {
|
|
fediact_homeinstance: null,
|
|
fediact_alert: false,
|
|
fediact_mode: "blacklist",
|
|
fediact_whitelist: null,
|
|
fediact_blacklist: null,
|
|
fediact_target: "_self",
|
|
fediact_autoaction: true,
|
|
fediact_token: null,
|
|
fediact_redirects: true,
|
|
fediact_enabledelay: true,
|
|
fediact_hidemuted: false,
|
|
fediact_runifloggedin: false,
|
|
fediact_mutes: [],
|
|
fediact_blocks: [],
|
|
fediact_domainblocks: []
|
|
}
|
|
const tmpSettings = {
|
|
fedireply: undefined,
|
|
lasthomerequest: undefined,
|
|
whitelist: undefined,
|
|
blacklist: undefined,
|
|
exturi: undefined,
|
|
tokenheader: undefined,
|
|
processed: [],
|
|
processedFollow: [],
|
|
isProcessing: []
|
|
}
|
|
|
|
// fix for cross-browser storage api compatibility and other global vars
|
|
var browser, chrome
|
|
|
|
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-=-
|
|
// =-=-=-=-=-= UTILS =-==-=-=-=
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-=-
|
|
|
|
// wrappers to prepend to log messages
|
|
function log(text) {
|
|
if (enableConsoleLog) {
|
|
console.log(logPrepend + ' ' + text)
|
|
}
|
|
}
|
|
|
|
// Custom solution for detecting inserted nodes
|
|
// Works in combination with nodeinserted.css (fixes Firefox blocking addon-inserted <style> elements for sites with CSP)
|
|
// Is more reliable/practicable in certain situations than mutationobserver, who will ignore any node that was inserted with its parent node at once
|
|
(function($) {
|
|
$.fn.DOMNodeAppear = function(callback, selector) {
|
|
if (!selector) {
|
|
return false
|
|
}
|
|
// catch all animationstart events
|
|
$(document).on('animationstart webkitAnimationStart oanimationstart MSAnimationStart', function(e){
|
|
// check if the animatonname equals our animation and if the element is one of our selectors
|
|
if (e.originalEvent.animationName == 'nodeInserted' && $(e.target).is(selector)) {
|
|
if (typeof callback == 'function') {
|
|
// return the complete object in the callback
|
|
callback(e)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
jQuery.fn.onAppear = jQuery.fn.DOMNodeAppear
|
|
})(jQuery)
|
|
|
|
// for checking if logged in on an external instance
|
|
function isLoggedIn() {
|
|
return new Promise(function(resolve) {
|
|
if ($(document).find("script#initial-state").length) {
|
|
var initialState = $(document).find("script#initial-state").first()
|
|
var stateJson = JSON.parse($(initialState).text())
|
|
if (stateJson.meta.access_token) {
|
|
resolve(true)
|
|
}
|
|
} else {
|
|
$(document).DOMNodeAppear(function(e) {
|
|
var initialState = $(e.target)
|
|
var stateJson = JSON.parse($(initialState).text())
|
|
if (stateJson.meta.access_token) {
|
|
resolve(true)
|
|
}
|
|
}, "script#initial-state")
|
|
}
|
|
resolve(false)
|
|
})
|
|
}
|
|
|
|
// extract given url parameter value
|
|
var getUrlParameter = function getUrlParameter(sParam) {
|
|
var sPageURL = window.location.search.substring(1),
|
|
sURLVariables = sPageURL.split('&'), sParameterName, i
|
|
for (i = 0; i < sURLVariables.length; i++) {
|
|
sParameterName = sURLVariables[i].split('=')
|
|
if (sParameterName[0] === sParam) {
|
|
return sParameterName[1] === undefined ? true : decodeURIComponent(sParameterName[1])
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
const asyncLimit = (fn, n) => {
|
|
let pendingPromises = []
|
|
return async function (...args) {
|
|
while (pendingPromises.length >= n) {
|
|
await Promise.race(pendingPromises).catch(() => {})
|
|
}
|
|
const p = fn.apply(this, args)
|
|
pendingPromises.push(p)
|
|
await p.catch(() => {})
|
|
pendingPromises = pendingPromises.filter(pending => pending !== p)
|
|
return p
|
|
}
|
|
}
|
|
|
|
// promisified xhr for api calls
|
|
function makeRequest(method, url, extraheaders, jsonbody) {
|
|
return new Promise(async function(resolve) {
|
|
// get current time
|
|
var currenttime = Date.now()
|
|
// try to prevent error 429 too many request by delaying home instance requests
|
|
if (~url.indexOf(settings.fediact_homeinstance) && settings.fediact_enabledelay) {
|
|
// get difference of current time and time of last request
|
|
var difference = currenttime - tmpSettings.lasthomerequest
|
|
// if difference is smaller than our set api delay value...
|
|
if (difference < apiDelay) {
|
|
// ... then wait the time required to reach the api delay value...
|
|
await new Promise(resolve => {
|
|
setTimeout(function() {
|
|
resolve()
|
|
}, apiDelay-difference)
|
|
})
|
|
}
|
|
// TODO: move this to the top? or get new Date.now() here?
|
|
tmpSettings.lasthomerequest = Date.now()
|
|
}
|
|
try {
|
|
await chrome.runtime.sendMessage({requestdata: [method, url, extraheaders, jsonbody]}, function(response) {
|
|
if(response) {
|
|
resolve(response)
|
|
} else {
|
|
resolve(false)
|
|
}
|
|
})
|
|
} catch (e) {
|
|
// if we encounter an error here, it is likely since the extension context got invalidated, so reload the page
|
|
log(e)
|
|
log("Reloading page, extension likely got updated or reloaded.")
|
|
location.reload()
|
|
}
|
|
})
|
|
}
|
|
|
|
// wrap so there are never more than 10 concurrent requests
|
|
const requestAsyncLimited = asyncLimit(makeRequest, maxAsyncRequests)
|
|
|
|
// Escape characters used for regex
|
|
function escapeRegExp(string) {
|
|
return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
|
|
}
|
|
|
|
// Replace all occurrences of a substring
|
|
function replaceAll(str, find, replace) {
|
|
return str.replace(new RegExp(escapeRegExp(find), 'g'), replace)
|
|
}
|
|
|
|
// handles redirects to home instance
|
|
function redirectTo(url) {
|
|
// check if redirects are enabled at all
|
|
if (settings.fediact_redirects) {
|
|
if (settings.fediact_target == "_self") {
|
|
/* If browser back button was used, flush cache */
|
|
(function () {
|
|
window.onpageshow = function(event) {
|
|
if (event.persisted) {
|
|
window.location.reload();
|
|
}
|
|
};
|
|
})()
|
|
}
|
|
// check if alert before redirect is enabled and show the prompt if so
|
|
if (settings.fediact_alert) {
|
|
if (!confirm("Redirecting to " + url)) {
|
|
return
|
|
}
|
|
}
|
|
// open the url in same/new tab
|
|
var win = window.open(url, settings.fediact_target)
|
|
log("Redirected to " + url)
|
|
// focus the new tab if open was successfull
|
|
if (win) {
|
|
win.focus()
|
|
} else {
|
|
// otherwise notify user...
|
|
log('Could not open new window. Please allow popups for this website.')
|
|
}
|
|
} else {
|
|
log("Redirects disabled.")
|
|
}
|
|
}
|
|
|
|
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=
|
|
// =-=-=-=-= INTERACTIONS =-=-=-=-=
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=
|
|
|
|
async function executeAction(data, action, polldata) {
|
|
var requestUrl, condition, jsonbody, after
|
|
var method = "POST"
|
|
switch (action) {
|
|
case 'copy':
|
|
// special action. only copy to clipboard and return
|
|
navigator.clipboard.writeText(data)
|
|
return true
|
|
case 'domainblock':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + domainBlocksApi + "?domain=" + data
|
|
condition = function(response) {if(response){return true}}
|
|
after = async function() {await updateMutedBlocked()}
|
|
break
|
|
case 'domainunblock':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + domainBlocksApi + "?domain=" + data
|
|
condition = function(response) {if(response){return true}}
|
|
method = "DELETE"
|
|
after = async function() {await updateMutedBlocked()}
|
|
break
|
|
case 'mute':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/" + data + "/mute"
|
|
condition = function(response) {return response.muting}
|
|
after = async function() {await updateMutedBlocked()}
|
|
break
|
|
case 'unmute':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/" + data + "/unmute"
|
|
condition = function(response) {return !response.muting}
|
|
after = async function() {await updateMutedBlocked()}
|
|
break
|
|
case 'block':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/" + data + "/block"
|
|
condition = function(response) {return response.blocking}
|
|
after = async function() {await updateMutedBlocked()}
|
|
break
|
|
case 'unblock':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/" + data + "/unblock"
|
|
condition = function(response) {return !response.blocking}
|
|
after = async function() {await updateMutedBlocked()}
|
|
break
|
|
case 'vote':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + pollsApi + "/" + data + "/votes"
|
|
condition = function(response) {return response.voted}
|
|
jsonbody = polldata
|
|
break
|
|
case 'follow':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/" + data + "/follow"
|
|
condition = function(response) {return response.following || response.requested}
|
|
break
|
|
case 'boost':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + statusApi + "/" + data + "/reblog"
|
|
condition = function(response) {return response.reblogged}
|
|
break
|
|
case 'favourite':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + statusApi + "/" + data + "/favourite"
|
|
condition = function(response) {return response.favourited}
|
|
break
|
|
case 'bookmark':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + statusApi + "/" + data + "/bookmark"
|
|
condition = function(response) {return response.bookmarked}
|
|
break
|
|
case 'unfollow':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/" + data + "/unfollow"
|
|
condition = function(response) {return !response.following && !response.requested}
|
|
break
|
|
case 'unboost':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + statusApi + "/" + data + "/unreblog"
|
|
condition = function(response) {return !response.reblogged}
|
|
break
|
|
case 'unfavourite':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + statusApi + "/" + data + "/unfavourite"
|
|
condition = function(response) {return !response.favourited}
|
|
break
|
|
case 'unbookmark':
|
|
requestUrl = 'https://' + settings.fediact_homeinstance + statusApi + "/" + data + "/unbookmark"
|
|
condition = function(response) {return !response.bookmarked}
|
|
break
|
|
default:
|
|
log("No valid action specified.")
|
|
return
|
|
}
|
|
if (requestUrl) {
|
|
var response = await requestAsyncLimited(method, requestUrl, tmpSettings.tokenheader, jsonbody)
|
|
if (response) {
|
|
// convert to json object
|
|
response = JSON.parse(response)
|
|
if (condition(response)) {
|
|
if (after !== undefined) {
|
|
await after()
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
log(action + " action failed.")
|
|
}
|
|
|
|
// allows to check if user is following one or multiple user IDs on the home instance
|
|
async function isFollowingHomeInstance(ids) {
|
|
var requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/relationships?"
|
|
// build the request url with one or multiple IDs
|
|
for (const id of ids) {
|
|
// trailing & is no issue
|
|
requestUrl += "id[]=" + id.toString() + "&"
|
|
}
|
|
// make the request
|
|
var responseFollowing = await requestAsyncLimited("GET", requestUrl, tmpSettings.tokenheader, null)
|
|
// fill response array according to id amount with false
|
|
const follows = Array(ids.length).fill(false)
|
|
// parse the response
|
|
if (responseFollowing) {
|
|
responseFollowing = JSON.parse(responseFollowing)
|
|
// iterate over ids and accounts in response
|
|
for (var i = 0; i < ids.length; i++) {
|
|
for (account of responseFollowing) {
|
|
// check if the current account matches the id at the current index
|
|
if (account.id == ids[i]) {
|
|
if (account.following || account.requested) {
|
|
// update the response array at the given index with true if the account is already followed
|
|
follows[i] = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return follows
|
|
}
|
|
|
|
// clear handle for comparison with mutes/blocks
|
|
function clearHandle(handle) {
|
|
// remove leading @
|
|
if (handle.startsWith("@")) {
|
|
handle = handle.slice(1)
|
|
}
|
|
// add local uri if handle has no domain already
|
|
if (handle.split("@").length-1 == 0) {
|
|
handle = handle + "@" + tmpSettings.exturi
|
|
}
|
|
return handle
|
|
}
|
|
|
|
function isBlocked(handle) {
|
|
handle = clearHandle(handle)
|
|
if (settings.fediact_blocks.includes(handle)) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
// check if handle is muted
|
|
function isMuted(handle) {
|
|
handle = clearHandle(handle)
|
|
if (settings.fediact_mutes.includes(handle)) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
// check if handle is domain blocked
|
|
function isDomainBlocked(handle) {
|
|
handle = clearHandle(handle)
|
|
if (settings.fediact_domainblocks.includes(handle.split("@")[1])) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
//execute the above 3 functions on a handle
|
|
function checkAllMutedBlocked(handle) {
|
|
if (isMuted(handle) || isBlocked(handle) || isDomainBlocked(handle)) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=
|
|
// =-=-=-=-=-= RESOLVING =-=-==-=-=
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=
|
|
|
|
// Return the user id on the users home instance
|
|
async function resolveHandleToHome(handle) {
|
|
var requestUrl = 'https://' + settings.fediact_homeinstance + accountsApi + "/search?q=" + handle + "&resolve=true&limit=1&exclude_unreviewed=false"
|
|
var searchResponse = await requestAsyncLimited("GET", requestUrl, tmpSettings.tokenheader, null)
|
|
if (searchResponse) {
|
|
searchResponse = JSON.parse(searchResponse)
|
|
if (searchResponse[0].id) {
|
|
// return the first account result
|
|
return [searchResponse[0].id, searchResponse[0].acct]
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// resolve a toot to the users home instance
|
|
async function resolveTootToHome(searchstring) {
|
|
var requestUrl = 'https://' + settings.fediact_homeinstance + searchApi + "/?q=" + searchstring + "&resolve=true&limit=1&exclude_unreviewed=false"
|
|
var response = await requestAsyncLimited("GET", requestUrl, tmpSettings.tokenheader, null)
|
|
if (response) {
|
|
response = JSON.parse(response)
|
|
// do we have a status as result?
|
|
if (!response.accounts.length && response.statuses.length) {
|
|
var status = response.statuses[0]
|
|
if (status.poll) {
|
|
return [[status.account.acct, status.id, status.reblogged, status.favourited, status.bookmarked, status.account.id], [status.poll.id, status.poll.voted]]
|
|
} else {
|
|
// return the required status data
|
|
return [[status.account.acct, status.id, status.reblogged, status.favourited, status.bookmarked, status.account.id], [false, false]]
|
|
}
|
|
} else {
|
|
return [false, false]
|
|
}
|
|
} else {
|
|
return [false, false]
|
|
}
|
|
}
|
|
|
|
// Get a toot's (external) home instance url by using the 302 redirect feature of mastodon
|
|
// we send a message with the toot url to the background script, which will perform the HEAD request
|
|
// since XMLHttpRequest/fetch do not allow access to the location header
|
|
// TODO: FALLBACK IF 302 IS NOT SUPPORTED
|
|
function resolveTootToExternalHome(tooturl) {
|
|
// TODO: check if a delay is necessary here too
|
|
if (tooturl) {
|
|
return new Promise(async function(resolve) {
|
|
try {
|
|
await chrome.runtime.sendMessage({externaltoot: tooturl}, function(response) {
|
|
if(response) {
|
|
resolve(response)
|
|
} else {
|
|
resolve(false)
|
|
}
|
|
})
|
|
} catch (e) {
|
|
// if we encounter an error here, it is likely since the extension context got invalidated, so reload the page
|
|
log(e)
|
|
log("Reloading page, extension likely got updated or reloaded.")
|
|
location.reload()
|
|
}
|
|
})
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=-=
|
|
// =-=-=-=-= SITE PROCESSING =-==-=-=
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=-=
|
|
|
|
// custom implementation for allowing to toggle inline css
|
|
function toggleInlineCss(el, styles, toggleclass) {
|
|
// toggle the active class (specified) on the element (specified), then check the current state
|
|
var active = $(el).toggleClass(toggleclass).hasClass(toggleclass)
|
|
// we can have multiple styles as input, so loop through them
|
|
for (var style of styles) {
|
|
// if the element now has the active class...
|
|
if (active) {
|
|
// set the third value as style (first value / 0 is style itself)
|
|
$(el).css(style[0], style[2])
|
|
} else {
|
|
// otherwise, if the second value is "!remove"...
|
|
if (style[1] == "!remove") {
|
|
// remove the inline css by regex replacing
|
|
var newinline = replaceAll($(el).attr('style'), style[0]+": "+style[2]+";", "")
|
|
$(el).attr('style', newinline)
|
|
} else {
|
|
// otherwise set the second value as style
|
|
$(el).css(style[0], style[1])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// check if an toot identifier is already in the "processed" array
|
|
function isInProcessedToots(id) {
|
|
// iterate array
|
|
for (var i = 0; i < tmpSettings.processed.length; i++) {
|
|
// if the the first value of the nested array at the current index matches the id we look for...
|
|
if (tmpSettings.processed[i][0] == id) {
|
|
// return the index
|
|
return i
|
|
}
|
|
}
|
|
// if none was found...
|
|
return false
|
|
}
|
|
|
|
// add a toot to the "processed" array
|
|
function addToProcessedToots(toot) {
|
|
// push the array first
|
|
tmpSettings.processed.push(toot)
|
|
// check the difference of the max elements to cache and the current length of the processed array
|
|
var diff = tmpSettings.processed.length - maxTootCache
|
|
// if diff is greater than 0...
|
|
if (diff > 0) {
|
|
// remove the first diff items from it
|
|
tmpSettings.processed = tmpSettings.processed.splice(0,diff)
|
|
}
|
|
return tmpSettings.processed.length - 1
|
|
}
|
|
|
|
function updateMutedBlocked() {
|
|
return new Promise(async function(resolve) {
|
|
try {
|
|
await chrome.runtime.sendMessage({updatemutedblocked: true}, async function(response) {
|
|
if (response) {
|
|
if (!await getSettings()) {
|
|
// but reload if settings are invalid
|
|
location.reload()
|
|
} else {
|
|
resolve(true)
|
|
}
|
|
} else {
|
|
resolve(false)
|
|
}
|
|
})
|
|
} catch (e) {
|
|
// if we encounter an error here, it is likely since the extension context got invalidated, so reload the page
|
|
log(e)
|
|
log("Reloading page, extension likely got updated or reloaded.")
|
|
location.reload()
|
|
}
|
|
})
|
|
}
|
|
|
|
function showModal(settings) {
|
|
// [ [action,tootdata],[action,tootdata] ]
|
|
var baseEl = $(modalHtml)
|
|
var appendTo = $(baseEl).find("ul")
|
|
for (const entry of settings) {
|
|
var append = "<li class='fediactmodalitem'><a class='fediactmodallink' fediactaction='" + entry[0] + "' fediactdata='" + entry[1] + "'><span>" + entry[2] + "</span></a></li>"
|
|
$(appendTo).append($(append))
|
|
}
|
|
$("body").append($(baseEl))
|
|
async function handleModalEvent(e) {
|
|
if (e.originalEvent.isTrusted) {
|
|
if ($(e.target).is(".fediactmodal li, .fediactmodal li *")) {
|
|
if (!$(e.target).is(".fediactmodal li a")) {
|
|
if ($(e.target).find("a").length) {
|
|
e.target = $(e.target).find("a")
|
|
} else {
|
|
e.target = $(e.target).closest("a")
|
|
}
|
|
}
|
|
var action = $(e.target).attr("fediactaction")
|
|
var data = $(e.target).attr("fediactdata")
|
|
var done = await executeAction(data, action, null)
|
|
if (done) {
|
|
$(e.target).addClass("activated")
|
|
$(e.target).append("<span>Done!</span>")
|
|
$(baseEl).css("animation", "fadeOut .2s .7s forwards")
|
|
$(baseEl).find(".fediactmodalinner").css("animation", "scaleInFade .2s .7s forwards reverse")
|
|
await new Promise(resolve => {
|
|
setTimeout(function() {
|
|
resolve()
|
|
}, 1000)
|
|
})
|
|
$(baseEl).remove()
|
|
$("body").off("click", handleModalEvent)
|
|
} else {
|
|
$(e.target).css("--confirmation", "red")
|
|
$(e.target).addClass("activated")
|
|
$(e.target).append("<span>Failed</span>")
|
|
$(baseEl).css("animation", "fadeOut .2s .7s forwards")
|
|
$(baseEl).find(".fediactmodalinner").css("animation", "scaleInFade .2s .7s forwards reverse")
|
|
await new Promise(resolve => {
|
|
setTimeout(function() {
|
|
resolve()
|
|
}, 1000)
|
|
})
|
|
$(baseEl).remove()
|
|
$("body").off("click", handleModalEvent)
|
|
}
|
|
} else if ($(e.target).is(".fediactmodalinner")) {
|
|
$.noop()
|
|
} else {
|
|
$(baseEl).remove()
|
|
$("body").off("click", handleModalEvent)
|
|
}
|
|
}
|
|
}
|
|
$("body").on("click", handleModalEvent)
|
|
}
|
|
|
|
function addFediElements() {
|
|
if (!$(".fediacticon").length) {
|
|
$("body").append("<div class='fediacticon'></div>")
|
|
$("body").append("<div class='fediactsettings_onsite'><div class='fediactsettings_onsite_inner'><a href='https://" + settings.fediact_homeinstance + "' target='" + settings.fediact_target + "'>Go home</a></div></div>")
|
|
function fediSettingsHandler(e) {
|
|
try {
|
|
if (e.originalEvent.isTrusted) {
|
|
if ($(e.target).is("div.fediacticon")) {
|
|
$("div.fediacticon").hide()
|
|
$("div.fediactsettings_onsite").show()
|
|
} else {
|
|
$("div.fediactsettings_onsite").hide()
|
|
$("div.fediacticon").show()
|
|
}
|
|
}
|
|
} catch {
|
|
$.noop()
|
|
}
|
|
}
|
|
$("body").on("click", fediSettingsHandler)
|
|
}
|
|
}
|
|
|
|
// trigger the reply button click - will only run when we are on a home instance url with fedireply parameter
|
|
async function processReply() {
|
|
// wait for the detailed status action bar to appear
|
|
$(document).DOMNodeAppear(function(e) {
|
|
// find the reply button and click it
|
|
$(e.target).find("button:has(i.fa-reply), button:has(i.fa-reply-all)").click()
|
|
}, "div.detailed-status__action-bar")
|
|
}
|
|
|
|
// process any toots found on supported sites
|
|
async function processToots() {
|
|
// determine action when a button is clicked (except reply, which will always redirect)
|
|
function getTootAction(e) {
|
|
// set to false initially
|
|
var action = false
|
|
// check if the clicked element has a retweet icon
|
|
if ($(e.currentTarget).children("i.fa-retweet").length) {
|
|
// if so, check if the retweet icon has the fediactive class (for all other buttons it will be the button element itself)
|
|
if ($(e.currentTarget).children("i.fa-retweet").hasClass("fediactive")) {
|
|
// yep, has the class - so this action should be unboost
|
|
action = "unboost"
|
|
} else {
|
|
// nope, so it will be a boost
|
|
action = "boost"
|
|
}
|
|
// repeat for favourite and bookmark
|
|
} else if ($(e.currentTarget).children("i.fa-star").length) {
|
|
if ($(e.currentTarget).hasClass("fediactive")) {
|
|
action = "unfavourite"
|
|
} else {
|
|
action = "favourite"
|
|
}
|
|
} else if ($(e.currentTarget).children("i.fa-bookmark").length) {
|
|
if ($(e.currentTarget).hasClass("fediactive")) {
|
|
action = "unbookmark"
|
|
} else {
|
|
action = "bookmark"
|
|
}
|
|
// should rarely reach this point, but some v3 instances include the action in the href only, so we have this as a fallback
|
|
// (v3 public view does NOT have a bookmark button)
|
|
} else if ($(e.currentTarget).attr("href")) {
|
|
// does the href include "type=reblog"?
|
|
if (~$(e.currentTarget).attr("href").indexOf("type=reblog")) {
|
|
// if so, do as above...
|
|
if ($(e.currentTarget).hasClass("fediactive")) {
|
|
action = "unboost"
|
|
} else {
|
|
action = "boost"
|
|
}
|
|
// repeat for favourite
|
|
} else if (~$(e.currentTarget).attr("href").indexOf("type=favourite")) {
|
|
if ($(e.currentTarget).hasClass("fediactive")) {
|
|
action = "unfavourite"
|
|
} else {
|
|
action = "favourite"
|
|
}
|
|
}
|
|
}
|
|
return action
|
|
}
|
|
// some toots contain an href which can be an already resolved external link or an internal reference
|
|
function tootHrefCheck(temp) {
|
|
// is it a full url?
|
|
if (temp.startsWith("http")) {
|
|
// yes, create a new URL() to access its parts
|
|
var tempUrl = new URL(temp)
|
|
// is the hostname of the URL the same as the current instance hostname?
|
|
if (location.hostname == tempUrl.hostname) {
|
|
// yes, so its a local toot id
|
|
temp = temp.split("/")
|
|
// handle trailing / case
|
|
var tempLast = temp.pop() || temp.pop()
|
|
return [false, tempLast]
|
|
} else {
|
|
// return full URL, since this is already a resolved link to the toot's home instance
|
|
return [true, temp]
|
|
}
|
|
} else {
|
|
// no, so it must be a local toot id as well
|
|
temp = temp.split("/")
|
|
var tempLast = temp.pop() || temp.pop()
|
|
return [false, tempLast]
|
|
}
|
|
}
|
|
// get only the toot author handle
|
|
function getTootAuthor(el) {
|
|
// find the element containing the display name and return text if found
|
|
if ($(el).find("span.display-name__account").length) {
|
|
return $(el).find("span.display-name__account").first().text().trim()
|
|
}
|
|
}
|
|
// check elements that can contain the local toot id and return it if found
|
|
function getTootInternalId(el) {
|
|
// detailed status wrapper - get id from current document url
|
|
if ($(el).is(".detailed-status__wrapper")) {
|
|
// we will use the last part of the URL path - this should be more universal than always selecting the fifth "/" slice
|
|
var temp = window.location.href.split("?")[0].split("/")
|
|
return (temp.pop() || temp.pop())
|
|
// otherwise check if current element has data-id attribute
|
|
} else if ($(el).attr("data-id")) {
|
|
// split by "-" to respect some ids startin with "f-"
|
|
return $(el).attr("data-id").split("-").slice(-1)[0]
|
|
// otherwise do the same for any closest article or div with the data-id attribute
|
|
} else if ($(el).closest("article[data-id], div[data-id]").length) {
|
|
return $(el).closest("article[data-id], div[data-id]").first().attr("data-id").split("-").slice(-1)[0]
|
|
} else if ($(el).find("a.icon-button:has(i.fa-star), a.detailed-status__link:has(i.fa-star)").length) {
|
|
var hrefEl = $(el).find("a.icon-button:has(i.fa-star), a.detailed-status__link:has(i.fa-star)").first()
|
|
if ($(hrefEl).attr("href")) {
|
|
var hrefAttr = $(hrefEl).attr("href")
|
|
if (~hrefAttr.indexOf("interact/")) {
|
|
var splitted = hrefAttr.split("?")[0].split("/")
|
|
var lastpart = splitted.pop() || splitted.pop()
|
|
return lastpart
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// check elements that can contain an href (either resolved external link or internal reference)
|
|
function getTootExtIntHref(el) {
|
|
// for each element possibly containing an href, check if its and external fully resolved href or an internal reference and return the first found
|
|
if ($(el).find("a.status__relative-time").length) {
|
|
return tootHrefCheck($(el).find("a.status__relative-time").first().attr("href").split("?")[0])
|
|
} else if ($(el).find("a.detailed-status__datetime").length) {
|
|
return tootHrefCheck($(el).find("a.detailed-status__datetime").first().attr("href").split("?")[0])
|
|
} else if ($(el).find("a.modal-button").length) {
|
|
return tootHrefCheck($(el).find("a.modal-button").first().attr("href").split("?")[0])
|
|
}
|
|
return [false,undefined]
|
|
}
|
|
// check toot author, mentions and toot prepend mentions for applying mutes
|
|
function processMutes(el, tootAuthor) {
|
|
if (settings.fediact_hidemuted) {
|
|
var hrefs = []
|
|
if ($(el).siblings(".status__prepend").length) {
|
|
var prepended = $(el).siblings(".status__prepend").first()
|
|
if ($(prepended).find("a").attr("href")) {
|
|
hrefs.push($(prepended).find("a").attr("href").split("?")[0])
|
|
}
|
|
}
|
|
// build array of mentions in @user@domain.com format
|
|
// NOTE: this will fail if ax external user handle uses another subdomain than hostname, but FediAct was not designed for that - this is best effort
|
|
$(el).find("span.h-card").each(function() {
|
|
hrefs.push($(this).find("a").attr("href").split("?")[0])
|
|
})
|
|
var processedHrefs = []
|
|
for (var href of hrefs) {
|
|
var splitted = href.split("/")
|
|
var lastpart = splitted.pop() || splitted.pop()
|
|
lastpart = lastpart.slice(1)
|
|
if (href.startsWith("http")) {
|
|
var url = new URL(href)
|
|
if (url.hostname != tmpSettings.exturi && url.hostname != location.hostname) {
|
|
// external handle
|
|
processedHrefs.push(lastpart + "@" + url.hostname)
|
|
} else {
|
|
processedHrefs.push(lastpart + "@" + tmpSettings.exturi)
|
|
}
|
|
} else {
|
|
processedHrefs.push(lastpart + "@" + tmpSettings.exturi)
|
|
}
|
|
}
|
|
if (processedHrefs.some(r=> checkAllMutedBlocked(r)) || checkAllMutedBlocked(tootAuthor)) {
|
|
$(el).hide()
|
|
if (prepended) {
|
|
$(prepended).hide()
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
// main function to process each detected toot element
|
|
async function process(el) {
|
|
addFediElements()
|
|
// extra step for detailed status elements to select the correct parent
|
|
if ($(el).is("div.detailed-status") && $(el).closest("div.focusable").length) {
|
|
var isDetailed = true
|
|
el = $(el).closest("div.focusable")
|
|
}
|
|
// get toot data
|
|
var tootAuthor = getTootAuthor($(el))
|
|
// check if mutes apply and return if so
|
|
if (processMutes(el, tootAuthor)) {
|
|
return
|
|
}
|
|
var tootInternalId = getTootInternalId($(el))
|
|
var [tootHrefIsExt, tootHrefOrId] = getTootExtIntHref($(el))
|
|
// we will always need an internal reference to the toot, be it an actual internal toot id or the href of a toot already resolved to its home
|
|
// tootInternalId will be preferred if both are set
|
|
var internalIdentifier = tootInternalId || tootHrefOrId
|
|
// do we have one of those?
|
|
if (internalIdentifier) {
|
|
var homeResolveStrings = []
|
|
var hasHiddenPoll = false
|
|
// check if id is already cached
|
|
var cacheIndex = isInProcessedToots(internalIdentifier)
|
|
// get all button elements of this toot
|
|
var favButton = $(el).find("button:has(i.fa-star)").first()
|
|
if (!$(favButton).length) {
|
|
favButton = $(el).find("a.icon-button:has(i.fa-star), a.detailed-status__link:has(i.fa-star)")
|
|
}
|
|
if (isDetailed) {
|
|
$("<div class='detailed-status__button fediactprocessingdetailed'><span class='fediactprocessing'></span></div>").insertAfter($(favButton).parent())
|
|
} else {
|
|
$("<span class='fediactprocessing'></span>").insertAfter($(favButton))
|
|
}
|
|
var boostButton = $(el).find("button:has(i.fa-retweet)").first()
|
|
if (!$(boostButton).length) {
|
|
boostButton = $(el).find("a.icon-button:has(i.fa-retweet), a.detailed-status__link:has(i.fa-retweet)")
|
|
}
|
|
var bookmarkButton = $(el).find("button:has(i.fa-bookmark)").first()
|
|
var replyButton = $(el).find("button:has(i.fa-reply), button:has(i.fa-reply-all), a.icon-button:has(i.fa-reply), a.icon-button:has(i.fa-reply-all)").first()
|
|
var spoilerButton = $(el).find('button[class*="show-more"]').first()
|
|
var voteButton = $(el).find("div.poll button").first()
|
|
if ($(spoilerButton).length) {
|
|
$(spoilerButton).click()
|
|
if ($(el).find("div.poll").length) {
|
|
hasHiddenPoll = true
|
|
}
|
|
$(spoilerButton).click()
|
|
}
|
|
var moreButton = $(el).find("button:has(i.fa-ellipsis-h,i.fa-ellipsis-fw,i.fa-ellipsis-v)").first()
|
|
// handles process when a vote button is clicked
|
|
async function pollAction(id, redirect, e) {
|
|
if (settings.fediact_autoaction) {
|
|
var pollData = {
|
|
choices: []
|
|
}
|
|
var pollDiv = $(e.currentTarget).closest("div.poll")
|
|
var listEls = $(pollDiv).find("li")
|
|
for (var i = 0; i < listEls.length; i++) {
|
|
if ($(listEls[i]).find("span.active").length) {
|
|
pollData.choices.push(String(i))
|
|
}
|
|
}
|
|
var result = await executeAction(id, "vote", pollData)
|
|
if (result) {
|
|
$(e.currentTarget).hide()
|
|
$(pollDiv).find("ul").replaceWith("<p class='fediactvoted'><a href='" + redirect + "' target='" + settings.fediact_target + "'>View the results</a> on your home instance.<p>")
|
|
if (cacheIndex) {
|
|
tmpSettings.processed[cacheIndex][10] = true
|
|
tmpSettings.processed[cacheIndex][11] = true
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
}
|
|
// handles process when a toot button is clicked
|
|
async function tootAction(id, e) {
|
|
if (settings.fediact_autoaction) {
|
|
// determine the action to perform
|
|
var action = getTootAction(e)
|
|
if (action) {
|
|
// resolve url on home instance to get local toot/author identifiers and toot status
|
|
var actionExecuted = await executeAction(id, action, null)
|
|
if (actionExecuted) {
|
|
if (cacheIndex) {
|
|
console.log(cacheIndex)
|
|
console.log(tmpSettings.processed[cacheIndex])
|
|
console.log(tmpSettings.processed)
|
|
// set interacted to true
|
|
tmpSettings.processed[cacheIndex][11] = true
|
|
}
|
|
// if the action was successfully executed, update the element styles
|
|
if (action == "boost" || action == "unboost") {
|
|
// toggle inline css styles
|
|
toggleInlineCss($(e.currentTarget),[["color","!remove","rgb(140, 141, 255)"]], "fediactive")
|
|
toggleInlineCss($(e.currentTarget).find("i"),[["transition-duration", "!remove", "0.9s"],["background-position", "!remove", "0px 100%"]], "fediactive")
|
|
// update element in cache if exists
|
|
if (cacheIndex) {
|
|
tmpSettings.processed[cacheIndex][3] = !tmpSettings.processed[cacheIndex][3]
|
|
}
|
|
// same for favourite, bookmarked....
|
|
} else if (action == "favourite" || action == "unfavourite") {
|
|
toggleInlineCss($(e.currentTarget),[["color","!remove","rgb(202, 143, 4)"]], "fediactive")
|
|
toggleInlineCss($(e.currentTarget).find("i"),[["animation","spring-rotate-out 1s linear","spring-rotate-in 1s linear"]], "fediactive")
|
|
if (cacheIndex) {
|
|
tmpSettings.processed[cacheIndex][4] = !tmpSettings.processed[cacheIndex][4]
|
|
}
|
|
} else {
|
|
toggleInlineCss($(e.currentTarget),[["color","!remove","rgb(255, 80, 80)"]], "fediactive")
|
|
if (cacheIndex) {
|
|
tmpSettings.processed[cacheIndex][5] = !tmpSettings.processed[cacheIndex][5]
|
|
}
|
|
}
|
|
return true
|
|
} else {
|
|
log("Could not execute action on home instance.")
|
|
}
|
|
} else {
|
|
log("Could not determine action.")
|
|
}
|
|
} else {
|
|
log("Auto-action disabled.")
|
|
return true
|
|
}
|
|
}
|
|
// handles initialization of element styles
|
|
function initStyles(tootdata) {
|
|
// always remove any existing "Unresolved" indicator from the element first
|
|
$(el).find(".fediactunresolveddetailed, .fediactunresolved").remove()
|
|
$(el).find(".fediactprocessingdetailed, .fediactprocessing").remove()
|
|
// is the toot unresolved?
|
|
if (!tootdata[1]) {
|
|
// yes, then add the Unresolved indicator
|
|
if (isDetailed) {
|
|
$("<div class='detailed-status__button fediactunresolveddetailed'><span class='fediactunresolved'>X</span></div>").insertAfter($(favButton).parent())
|
|
} else {
|
|
$("<span class='fediactunresolved'>X</span>").insertAfter($(favButton))
|
|
}
|
|
} else {
|
|
// otherwise start processing button styles (if enabled OR if the toot was already interacted with, to restore the state while still on the same page)
|
|
// first enable the bookmark button (is disabled on external instances)
|
|
$(bookmarkButton).removeClass("disabled").removeAttr("disabled")
|
|
$(moreButton).removeClass("disabled").removeAttr("disabled")
|
|
// special care for polls that are hidden behind a CW
|
|
if (tootdata[13]) {
|
|
// click initially to show content
|
|
$(spoilerButton).click()
|
|
$(spoilerButton).find("span").text("Show less")
|
|
// set voteButton
|
|
voteButton = $(el).find("div.poll button").first()
|
|
// set handling for all new clicks
|
|
$(spoilerButton).on("click", function(e) {
|
|
// prevent default etc.
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
var spanText = $(spoilerButton).find("span")
|
|
if ($(spanText).text() == "Show less") {
|
|
$(spanText).text("Show more")
|
|
} else {
|
|
$(spanText).text("Show less")
|
|
}
|
|
// toggle the css manually to hide/show the content/poll
|
|
toggleInlineCss($(el).find("div.poll").first(),[["display","block","none"]], "fedihideshow")
|
|
toggleInlineCss($(el).find("div.status__content__text").first(),[["display","block","none"]], "fedihideshow")
|
|
})
|
|
// click again so it is hidden by default, like usually
|
|
$(spoilerButton).click()
|
|
}
|
|
$(voteButton).removeAttr("disabled")
|
|
// set the toot buttons to active, depending on the state of the resolved toot and if the element already has the active class
|
|
if (tootdata[4]) {
|
|
if (!$(favButton).hasClass("fediactive")) {
|
|
toggleInlineCss($(favButton),[["color","!remove","rgb(202, 143, 4)"]], "fediactive")
|
|
toggleInlineCss($(favButton).find("i"),[["animation","spring-rotate-out 1s linear","spring-rotate-in 1s linear"]], "fediactive")
|
|
}
|
|
}
|
|
// repeat for other buttons
|
|
if (tootdata[3]) {
|
|
if (!$(boostButton).find("i.fediactive").length) {
|
|
toggleInlineCss($(boostButton),[["color","!remove","rgb(140, 141, 255)"]], "fediactive")
|
|
toggleInlineCss($(boostButton).find("i"),[["transition-duration", "!remove", "0.9s"],["background-position", "!remove", "0px 100%"]], "fediactive")
|
|
}
|
|
}
|
|
if (tootdata[5]) {
|
|
if (!$(bookmarkButton).hasClass("fediactive")) {
|
|
toggleInlineCss($(bookmarkButton),[["color","!remove","rgb(255, 80, 80)"]], "fediactive")
|
|
}
|
|
}
|
|
if (tootdata[10]) {
|
|
$(voteButton).hide()
|
|
$(voteButton).closest("div.poll").find("ul").replaceWith("<p class='fediactvoted'><a href='" + tootdata[7] + "' target='" + settings.fediact_target + "'>View the results</a> on your home instance.<p>")
|
|
}
|
|
}
|
|
}
|
|
// handles binding of clicks events for all buttons of a toot
|
|
function clickBinder(tootdata) {
|
|
var domainsplit = tootdata[1].split("@")
|
|
var domain = domainsplit.pop() || domainsplit.pop()
|
|
// reply button is simple, it will always redirect to the homeinstance with the fedireply parameter set
|
|
$(replyButton).on("click", function(e){
|
|
// prevent default and immediate propagation
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
if (e.originalEvent.isTrusted) {
|
|
// redirect to the resolved URL + fedireply parameter (so the extension can handle it after redirect)
|
|
redirectTo(tootdata[7]+"?fedireply")
|
|
}
|
|
})
|
|
$(moreButton).on("click", function(e){
|
|
// prevent default and immediate propagation
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
if (e.originalEvent.isTrusted) {
|
|
var modalLinks = []
|
|
if (isBlocked(tootdata[1])) {
|
|
modalLinks.push(["unblock",tootdata[6],"Unblock user"])
|
|
} else {
|
|
modalLinks.push(["block",tootdata[6],"Block user"])
|
|
}
|
|
if (isMuted(tootdata[1])) {
|
|
modalLinks.push(["unmute",tootdata[6],"Unmute user"])
|
|
} else {
|
|
modalLinks.push(["mute",tootdata[6],"Mute user"])
|
|
}
|
|
if (isDomainBlocked(tootdata[1])) {
|
|
modalLinks.push(["domainunblock",domain,"Unblock domain"])
|
|
} else {
|
|
modalLinks.push(["domainblock",domain,"Block domain"])
|
|
}
|
|
modalLinks.push(["copy",tootdata[12],"Copy URL"])
|
|
modalLinks.push(["copy",tootdata[7],"Copy home URL"])
|
|
showModal(modalLinks)
|
|
}
|
|
})
|
|
// for all other buttons...
|
|
$([favButton, boostButton, bookmarkButton, voteButton]).each(function() {
|
|
if ($(voteButton).length) {
|
|
if ($(voteButton).get(0).isEqualNode($(this).get(0))) {
|
|
var isVote = true
|
|
}
|
|
}
|
|
// these behave differently with single / double click
|
|
// we use a custom solution for handling dblclick since the default event does not work here
|
|
// init function global vars required for single/double click handling
|
|
var clicks = 0
|
|
var timer
|
|
$(this).on("click", async function(e) {
|
|
// prevent default and immediate propagation
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
if (e.originalEvent.isTrusted) {
|
|
// increase click counter
|
|
clicks++
|
|
// this will always run, but see below for double click handling
|
|
if (clicks == 1) {
|
|
timer = setTimeout(async function() {
|
|
if (isVote && !tootdata[10]) {
|
|
var actionExecuted = pollAction(tootdata[9], tootdata[7], e)
|
|
} else {
|
|
// execute action on click and get result (fail/success)
|
|
var actionExecuted = await tootAction(tootdata[2], e)
|
|
}
|
|
if (!actionExecuted) {
|
|
log("Action failed.")
|
|
}
|
|
// reset clicks
|
|
clicks = 0
|
|
}, 350)
|
|
} else {
|
|
// if we get here, the element was clicked twice before the above timeout was over, so this is a double click
|
|
// reset the above timeout so it wont execute
|
|
clearTimeout(timer)
|
|
if (isVote) {
|
|
var actionExecuted = pollAction(tootdata[9], tootdata[7], e)
|
|
} else {
|
|
// execute action on click and get result (fail/success)
|
|
var actionExecuted = await tootAction(tootdata[2], e)
|
|
}
|
|
if (!actionExecuted) {
|
|
log("Action failed.")
|
|
} else {
|
|
// redirect to home instance with the resolved toot url
|
|
redirectTo(tootdata[7])
|
|
}
|
|
// reset clicks
|
|
clicks = 0
|
|
}
|
|
}
|
|
}).on("dblclick", function(e) {
|
|
// default dblclick event must be prevented
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
})
|
|
})
|
|
}
|
|
// if element is not in cache, resolve it
|
|
if (!cacheIndex) {
|
|
// always add the already resolved external toot href first, if it was set
|
|
if (tootHrefIsExt) {
|
|
homeResolveStrings.push(tootHrefOrId)
|
|
}
|
|
// we can only process internalTootIds if we also have a user handle
|
|
if (tootAuthor) {
|
|
// get handle/handledomain without @
|
|
var matches = tootAuthor.match(handleExtractUrlRegex)
|
|
var [isExternalHandle, extHomeResolved] = [false, false]
|
|
// if we have a handledomain...
|
|
if (matches.groups.handledomain) {
|
|
// check if the current hostname includes that handle domain...
|
|
if (!(~location.hostname.indexOf(matches.groups.handledomain))) {
|
|
isExternalHandle = true
|
|
}
|
|
}
|
|
// add ids
|
|
var internalTootIds = [tootInternalId]
|
|
if (!tootHrefIsExt) {
|
|
internalTootIds.push(tootHrefOrId)
|
|
}
|
|
// filter duplicates and undefined values (shorter than checking with if clauses when adding...)
|
|
internalTootIds = internalTootIds.filter((element, index) => {
|
|
return (element !== undefined && internalTootIds.indexOf(element) == index)
|
|
})
|
|
// loop through internal ids (will be only 1 normally, but we want to maximize our chances for resolving later on)
|
|
for (var internalTootId of internalTootIds) {
|
|
// if its not an external handle...
|
|
if (!isExternalHandle) {
|
|
// add resolve strings for both formats on the current external instance
|
|
homeResolveStrings.push(location.protocol + "//" + location.hostname + "/users/" + matches.groups.handle + "/statuses/" + internalTootId)
|
|
homeResolveStrings.push(location.protocol + "//" + location.hostname + "/@" + matches.groups.handle + "/" + internalTootId)
|
|
// otherwise, start external resolve process if not done already for one of the internalTootIds
|
|
} else if (!extHomeResolved) {
|
|
var extResolveString = location.protocol + '//' + location.hostname + "/" + tootAuthor + "/" + internalTootId
|
|
var resolveTootHome = await resolveTootToExternalHome(extResolveString)
|
|
if (resolveTootHome) {
|
|
// update var so next tootid will not be resolved externally, if any more
|
|
extHomeResolved = true
|
|
// always push the originally returned url
|
|
homeResolveStrings.push(resolveTootHome)
|
|
// if it matches the URI format, also add the @ format
|
|
if (handleExtractUriRegex.test(resolveTootHome)) {
|
|
var tmpmatches = resolveTootHome.match(handleExtractUriRegex)
|
|
if (tmpmatches.groups.handle && tmpmatches.groups.tootid && tmpmatches.groups.domain) {
|
|
homeResolveStrings.push(tmpmatches.groups.domain + "/@" + tmpmatches.groups.handle + "/" + tmpmatches.groups.tootid)
|
|
}
|
|
// otherwise, if it matches the @ format, also add the URI format
|
|
} else if (handleExtractUrlRegex.test(resolveTootHome)) {
|
|
var tmpmatches = resolveTootHome.match(handleExtractUrlRegex)
|
|
if (tmpmatches.groups.handle && tmpmatches.groups.tootid && tmpmatches.groups.domain) {
|
|
homeResolveStrings.push(tmpmatches.groups.domain + "/users/" + tmpmatches.groups.handle + "/statuses/" + tmpmatches.groups.tootid)
|
|
}
|
|
}
|
|
}
|
|
// always add fallback to current external instance URL (for external handles, there is no /users/... format)
|
|
homeResolveStrings.push(location.protocol + "//" + location.hostname + "/" + tootAuthor + "/" + internalTootId)
|
|
}
|
|
}
|
|
}
|
|
// if we have any resolve strings to resolve on our home instance...
|
|
if (homeResolveStrings.length) {
|
|
// filter duplicates
|
|
homeResolveStrings = homeResolveStrings.filter((element, index) => {
|
|
return (homeResolveStrings.indexOf(element) == index)
|
|
})
|
|
// initialize with false
|
|
var resolvedToHomeInstance = false
|
|
// for each resolve string...
|
|
for (var homeResolveString of homeResolveStrings) {
|
|
// run only if not already resolved
|
|
if (!resolvedToHomeInstance) {
|
|
// resolve toot on actual home instance
|
|
var [resolvedToot, poll] = await resolveTootToHome(homeResolveString) // [status.account.acct, status.id, status.reblogged, status.favourited, status.bookmarked, status.account.id], [pollid/false, voted]
|
|
if (resolvedToot) {
|
|
// if successful, set condition to true (so it will not be resolved twice)
|
|
resolvedToHomeInstance = true
|
|
// set the redirect to home instance URL in @ format
|
|
var redirectUrl = 'https://' + settings.fediact_homeinstance + "/@" + resolvedToot[0] + "/" + resolvedToot[1]
|
|
// prepare the cache entry / toot data entry
|
|
var fullEntry = [internalIdentifier, ...resolvedToot, redirectUrl, true, ...poll, false, homeResolveString, hasHiddenPoll]
|
|
// 0: internal identifier; 1: toot home acct / false 2: toot home id 3: toot reblogged 4: toot favourited 5: toot bookmarked 6: home account id
|
|
// 7: redirect url 8: ??? crap! 9: poll id / false 10: poll voted 11: interacted 12: original URL that was resolved 13: has hidden poll?
|
|
}
|
|
}
|
|
}
|
|
// was any resolve successful?
|
|
if (resolvedToHomeInstance) {
|
|
// yes, so add to processed toots with the full toot data entry
|
|
cacheIndex = addToProcessedToots(fullEntry)
|
|
// ... and init styles
|
|
initStyles(fullEntry)
|
|
// continue with click handling...
|
|
clickBinder(fullEntry)
|
|
} else {
|
|
// no, but we will still add the toot to cache as unresolved
|
|
log("Failed to resolve: "+homeResolveStrings)
|
|
cacheIndex = addToProcessedToots([internalIdentifier, false])
|
|
initStyles([internalIdentifier, false])
|
|
}
|
|
} else {
|
|
// no resolve possible without any resolve strings, but we will still add the toot to cache as unresolved
|
|
log("Could not identify a post URI for home resolving.")
|
|
cacheIndex = addToProcessedToots([internalIdentifier, false])
|
|
initStyles([internalIdentifier, false])
|
|
}
|
|
} else {
|
|
// the toot is already in cache, so grab it
|
|
var toot = tmpSettings.processed[cacheIndex]
|
|
// init stylings
|
|
initStyles(toot)
|
|
// if it is NOT unresolved, bind click handlers again
|
|
if (toot[1]) {
|
|
clickBinder(toot)
|
|
}
|
|
}
|
|
} else {
|
|
log("Could not get toot data.")
|
|
}
|
|
}
|
|
// One DOMNodeAppear to rule them all
|
|
$(document).DOMNodeAppear(async function(e) {
|
|
if (!tmpSettings.isProcessing.includes($(e.target).get(0))) {
|
|
tmpSettings.isProcessing.push($(e.target).get(0))
|
|
process($(e.target))
|
|
}
|
|
}, "div.status, div.detailed-status")
|
|
// try to find all existing elements (fixes some elements not being detected by DOMNodeAppear in rare cases, esp. v3)
|
|
$(document).find("div.status, div.detailed-status").each(function(){
|
|
if (!tmpSettings.isProcessing.includes($(this).get(0))) {
|
|
tmpSettings.isProcessing.push($(this).get(0))
|
|
process($(this))
|
|
}
|
|
})
|
|
}
|
|
|
|
// main function to process profile views / follow buttons
|
|
async function processProfile() {
|
|
// for mastodon v3 - v4 does not show follow buttons / account cards on /explore
|
|
async function process(el) {
|
|
addFediElements()
|
|
var fullHandle, icon
|
|
var action = "follow"
|
|
var moreButton = $(el).siblings("button:has(i.fa-ellipsis-fw,i.fa-ellipsis-v,i.fa-ellipsis-h)")
|
|
// wrapper for follow/unfollow action
|
|
async function execFollow(id) {
|
|
if (settings.fediact_autoaction) {
|
|
// execute action and save result
|
|
var response = await executeAction(id, action, null)
|
|
// if action was successful, update button text and action value according to performed action
|
|
if (action == "follow" && response) {
|
|
if ($(icon).length) {
|
|
$(icon).removeClass("fa-user-plus").addClass("fa-user")
|
|
$(el).append("-")
|
|
$(el).attr("title","Unfollow")
|
|
} else {
|
|
$(el).text("Unfollow")
|
|
}
|
|
action = "unfollow"
|
|
return true
|
|
// repeat for unfollow action
|
|
} else if (action == "unfollow" && response) {
|
|
if ($(icon).length) {
|
|
$(icon).removeClass("fa-user").addClass("fa-user-plus")
|
|
$(el).contents().filter((_, node) => node.nodeType === 3).remove()
|
|
$(el).attr("title","Follow")
|
|
} else {
|
|
$(el).text("Follow")
|
|
}
|
|
action = "follow"
|
|
return true
|
|
}
|
|
} else {
|
|
log("Auto-action disabled.")
|
|
return true
|
|
}
|
|
}
|
|
// for mastodon v3 explore page
|
|
if ($(el).closest("div.account-card").length) {
|
|
fullHandle = $(el).closest("div.account-card").find("div.display-name > span").text().trim()
|
|
} else if($(el).closest("div.directory__card").length) {
|
|
fullHandle = $(el).closest("div.directory__card").find("div.display-name > span").text().trim()
|
|
icon = $(el).find("i").first()
|
|
} else {
|
|
// for all other pages, where only one of the selection elements is present
|
|
for (const selector of profileNamePaths) {
|
|
if ($(selector).length) {
|
|
fullHandle = $(selector).text().trim()
|
|
if (fullHandle.split("@").length-1 == 1) {
|
|
fullHandle = fullHandle + "@" + tmpSettings.exturi
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
// do we have a full handle?
|
|
if (fullHandle) {
|
|
if (!tmpSettings.processedFollow.includes(fullHandle)) {
|
|
$("<span class='fediactprocessing'></span>").insertBefore($(el))
|
|
// yes, so resolve it to a user id on our homeinstance
|
|
var resolvedHandle = await resolveHandleToHome(fullHandle)
|
|
if (resolvedHandle) {
|
|
tmpSettings.processedFollow.push(fullHandle)
|
|
if ($(moreButton).length) {
|
|
$(moreButton).removeClass("disabled").removeAttr("disabled")
|
|
}
|
|
var domainsplit = fullHandle.split("@")
|
|
var domain = domainsplit.pop() || domainsplit.pop()
|
|
var redirectUrl = 'https://' + settings.fediact_homeinstance + '/@' + resolvedHandle[1]
|
|
// successfully resolved
|
|
// ... then check if user is already following
|
|
var isFollowing = await isFollowingHomeInstance([resolvedHandle[0]])
|
|
// update button text and action if already following
|
|
if (isFollowing[0]) {
|
|
if ($(icon).length) {
|
|
$(icon).removeClass("fa-user-plus").addClass("fa-user")
|
|
$(el).append("-")
|
|
$(el).attr("title","Unfollow")
|
|
} else {
|
|
$(el).text("Unfollow")
|
|
}
|
|
action = "unfollow"
|
|
}
|
|
$(moreButton).on("click", function(e){
|
|
// prevent default and immediate propagation
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
if (e.originalEvent.isTrusted) {
|
|
var modalLinks = []
|
|
if (isBlocked(fullHandle)) {
|
|
modalLinks.push(["unblock",resolvedHandle[0],"Unblock user"])
|
|
} else {
|
|
modalLinks.push(["block",resolvedHandle[0],"Block user"])
|
|
}
|
|
if (isMuted(fullHandle)) {
|
|
modalLinks.push(["unmute",resolvedHandle[0],"Unmute user"])
|
|
} else {
|
|
modalLinks.push(["mute",resolvedHandle[0],"Mute user"])
|
|
}
|
|
if (isDomainBlocked(fullHandle)) {
|
|
modalLinks.push(["domainunblock",domain,"Unblock domain"])
|
|
} else {
|
|
modalLinks.push(["domainblock",domain,"Block domain"])
|
|
}
|
|
modalLinks.push(["copy",redirectUrl,"Copy home URL"])
|
|
showModal(modalLinks)
|
|
}
|
|
})
|
|
// single and double click handling (see toot processing for explanation, is the same basically)
|
|
var clicks = 0
|
|
var timer
|
|
$(el).on("click", async function(e) {
|
|
// prevent default and immediate propagation
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
if (e.originalEvent.isTrusted) {
|
|
clicks++
|
|
if (clicks == 1) {
|
|
timer = setTimeout(async function() {
|
|
execFollow(resolvedHandle[0])
|
|
clicks = 0
|
|
}, 350)
|
|
} else {
|
|
clearTimeout(timer)
|
|
var done = await execFollow(resolvedHandle[0])
|
|
if (done) {
|
|
if ($(icon).length) {
|
|
var classes = $(icon).attr("class")
|
|
$(icon).removeClass("fa-user").removeClass("fa-user-plus").addClass("fa-arrow-right")
|
|
} else {
|
|
var saveText = $(el).text()
|
|
$(el).text("Redirecting...")
|
|
}
|
|
setTimeout(function() {
|
|
redirectTo(redirectUrl)
|
|
if ($(icon).length) {
|
|
$(icon).attr("class", classes)
|
|
} else {
|
|
$(el).text(saveText)
|
|
}
|
|
}, 1000)
|
|
} else {
|
|
log("Action failed.")
|
|
}
|
|
clicks = 0
|
|
}
|
|
}
|
|
}).on("dblclick", function(e) {
|
|
e.preventDefault()
|
|
e.stopImmediatePropagation()
|
|
})
|
|
} else {
|
|
log("Could not resolve user home ID.")
|
|
}
|
|
$(el).siblings(".fediactprocessing").remove()
|
|
}
|
|
}
|
|
}
|
|
// create css selector from selector array
|
|
var allFollowPaths = followButtonPaths.join(",")
|
|
// one domnodeappear to rule them all
|
|
$(document).DOMNodeAppear(async function(e) {
|
|
if (!tmpSettings.isProcessing.includes($(e.target).get(0))) {
|
|
tmpSettings.isProcessing.push($(e.target).get(0))
|
|
process($(e.target))
|
|
}
|
|
}, allFollowPaths)
|
|
// try to find all existing elements (fixes some elements not being detected by DOMNodeAppear in rare cases, esp. v3)
|
|
$(document).find(allFollowPaths).each(function(){
|
|
if (!tmpSettings.isProcessing.includes($(this).get(0))) {
|
|
tmpSettings.isProcessing.push($(this).get(0))
|
|
process($(this))
|
|
}
|
|
})
|
|
}
|
|
|
|
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=-=
|
|
// =-=-=-=-=-= SETUP / RUN =-==-=-=-=
|
|
// =-=-=-=-==-=-=-=-==-=-=-=-==-=-=-=
|
|
|
|
// process white/blacklist from ext settings
|
|
function processDomainList(newLineList) {
|
|
// split by new line
|
|
var arrayFromList = newLineList.split(/\r?\n/)
|
|
// array to put checked domains into
|
|
var cleanedArray = []
|
|
for (var domain of arrayFromList) {
|
|
// remove whitespace
|
|
domain = domain.trim()
|
|
if (domain.length) {
|
|
if (domainRegex.test(domain)) {
|
|
cleanedArray.push(domain)
|
|
} else {
|
|
log("Removed invalid domain " + domain + " from blacklist/whitelist.")
|
|
}
|
|
}
|
|
}
|
|
// return newly created set (remvoes duplicates)
|
|
return [...new Set(cleanedArray)]
|
|
}
|
|
|
|
function checkSettings() {
|
|
// if the home instance is undefined/null/empty
|
|
if (settings.fediact_homeinstance == null || !settings.fediact_homeinstance) {
|
|
log("Mastodon home instance is not set.")
|
|
return false
|
|
}
|
|
// no token for api available (see background.js)
|
|
if (!settings.fediact_token) {
|
|
log("No API token available. Are you logged in to your home instance? If yes, wait for 1-2 minutes and reload page.")
|
|
return false
|
|
} else {
|
|
tmpSettings.tokenheader = {"Authorization":"Bearer " + settings.fediact_token,}
|
|
}
|
|
// if the value looks like a domain...
|
|
if (!(domainRegex.test(settings.fediact_homeinstance))) {
|
|
log("Instance setting is not a valid domain name.")
|
|
return false
|
|
}
|
|
if (settings.fediact_mode == "whitelist") {
|
|
// if in whitelist mode and the cleaned whitelist is empty, return false
|
|
tmpSettings.whitelist = processDomainList(settings.fediact_whitelist)
|
|
if (tmpSettings.whitelist.length < 1) {
|
|
log("Whitelist is empty or invalid.")
|
|
return false
|
|
}
|
|
} else {
|
|
// also process the blacklist if in blacklist mode, but an empty blacklist is OK so we do not return false
|
|
tmpSettings.blacklist = processDomainList(settings.fediact_blacklist)
|
|
}
|
|
return true
|
|
}
|
|
|
|
// test if the current site should be processed or not
|
|
// this will also be the function for whitelist/blacklist feature
|
|
async function checkSite() {
|
|
// is this site on our home instance?
|
|
if (location.hostname == settings.fediact_homeinstance) {
|
|
tmpSettings.fedireply = getUrlParameter("fedireply")
|
|
if (!tmpSettings.fedireply) {
|
|
log("Current site is your home instance.")
|
|
return false
|
|
}
|
|
}
|
|
// are we in whitelist mode?
|
|
if (settings.fediact_mode == "whitelist") {
|
|
// if so, check if site is NOT in whitelist
|
|
if ($.inArray(location.hostname, tmpSettings.whitelist) < 0) {
|
|
log("Current site is not in whitelist.")
|
|
return false
|
|
}
|
|
} else {
|
|
// otherwise we are in blacklist mode, so check if site is on blacklist
|
|
if ($.inArray(location.hostname, tmpSettings.blacklist) > -1) {
|
|
log("Current site is in blacklist.")
|
|
return false
|
|
}
|
|
}
|
|
// last check - and probably the most accurate to determine if it actually is mastadon
|
|
var requestUrl = location.protocol + '//' + location.hostname + instanceApi
|
|
// call instance api to confirm its mastodon and get normalized handle uri
|
|
var response = await requestAsyncLimited("GET", requestUrl, null, null)
|
|
// todo: add basic check for "mastodon" string in response
|
|
if (response) {
|
|
var uri = JSON.parse(response).uri
|
|
if (uri) {
|
|
if (uri.startsWith("http")) {
|
|
uri = new URL(uri)
|
|
tmpSettings.exturi = uri.hostname
|
|
} else {
|
|
tmpSettings.exturi = uri
|
|
}
|
|
// at this point, we know that it's mastodon and the background processor should start running
|
|
if (!backgroundProcessor()) {
|
|
log("Could not start background processor.")
|
|
return false
|
|
}
|
|
// if option is enabled, check if logged in on that instance and stop
|
|
if (!settings.fediact_runifloggedin && !tmpSettings.fedireply) {
|
|
if (await isLoggedIn()) {
|
|
log("Already logged in to this external instance.")
|
|
return false
|
|
}
|
|
}
|
|
} else {
|
|
return false
|
|
}
|
|
} else {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
async function backgroundProcessor() {
|
|
// wait for any url change messages from background script
|
|
chrome.runtime.onMessage.addListener(async function(request, sender, sendResponse) {
|
|
if (request.urlchanged) {
|
|
// reset already processed elements
|
|
tmpSettings.processed = []
|
|
tmpSettings.processedFollow = []
|
|
tmpSettings.isProcessing = []
|
|
$(".fediacticon").remove()
|
|
$(".fediactsettings_onsite").remove()
|
|
try {
|
|
$("body").off("click", fediSettingsHandler)
|
|
} catch {
|
|
$.noop()
|
|
}
|
|
// rerun getSettings to keep mutes/blocks up to date while not reloading the page
|
|
if (!await getSettings()) {
|
|
// but reload if settings are invalid
|
|
location.reload()
|
|
}
|
|
}
|
|
// if the settings were updated, we do a page reload
|
|
if (request.updatedfedisettings) {
|
|
location.reload()
|
|
}
|
|
})
|
|
// send message to initialize onUpdated listener in background script (this way it gets the tabid and we do not need to bind the listener for ALL sites)
|
|
try {
|
|
await chrome.runtime.sendMessage({running: true})
|
|
return true
|
|
} catch(e) {
|
|
log(e)
|
|
}
|
|
return false
|
|
}
|
|
|
|
function getSettings() {
|
|
// get setting
|
|
return new Promise(async function(resolve) {
|
|
try {
|
|
settings = await (browser || chrome).storage.local.get(settingsDefaults)
|
|
} catch(e) {
|
|
log(e)
|
|
resolve(false)
|
|
return
|
|
}
|
|
if (settings) {
|
|
// validate settings
|
|
if (checkSettings()) {
|
|
resolve(true)
|
|
} else {
|
|
resolve(false)
|
|
}
|
|
} else {
|
|
resolve(false)
|
|
}
|
|
})
|
|
}
|
|
|
|
// run wrapper
|
|
async function run() {
|
|
// validate settings
|
|
if (await getSettings()) {
|
|
// check site (if and which scripts should run)
|
|
if (await checkSite()) {
|
|
if (tmpSettings.fedireply) {
|
|
processReply()
|
|
} else {
|
|
processProfile()
|
|
processToots()
|
|
}
|
|
} else {
|
|
log("Will not process this site.")
|
|
}
|
|
} else {
|
|
log("Could not load settings.")
|
|
}
|
|
}
|
|
|
|
run() |