Control the content displayed in your activity feeds
// ==UserScript==
// @name Anilist: Activity-Feed Filter
// @namespace https://github.com/SeyTi01/
// @version 1.8.5
// @description Control the content displayed in your activity feeds
// @author SeyTi01
// @match https://anilist.co/*
// @grant none
// @license MIT
// ==/UserScript==
const config = {
remove: {
images: false, // Remove activities with images
gifs: false, // Remove activities with gifs
videos: false, // Remove activities with videos
text: false, // Remove activities with only text
uncommented: false, // Remove activities without comments
unliked: false, // Remove activities without likes
containsStrings: [], // Remove activities containing user-defined strings
},
options: {
targetLoadCount: 2, // Minimum number of activities to display per "Load More" button click
caseSensitive: false, // Use case-sensitive matching for string-based removal
reverseConditions: false, // Display only posts that meet the specified removal conditions
linkedConditions: [], // Groups of conditions to be evaluated together
},
runOn: {
home: true, // Run the script on the home feed
social: true, // Run the script on the 'Recent Activity' of anime/manga entries
profile: false, // Run the script on user profile feeds
guestHome: false, // Run the script on the home feed for non-user visitors
},
};
class MainApp {
constructor(activityHandler, uiHandler, config) {
this.ac = activityHandler;
this.ui = uiHandler;
this.config = config;
this.URLS = {
home: 'https://anilist.co/home',
social: 'https://anilist.co/*/social',
profile: 'https://anilist.co/user/*/',
guestHome: 'https://anilist.co/social',
};
}
initializeObserver() {
this.observer = new MutationObserver(this._observeMutations.bind(this));
this.observer.observe(document.body, { childList: true, subtree: true });
}
_observeMutations(mutations) {
if (this._isUrlAllowed()) {
mutations.forEach(mutation => mutation.addedNodes.forEach(node => this._handleAddedNode(node)));
this._processLoadOrReset();
}
}
_handleAddedNode(node) {
if (!(node instanceof HTMLElement)) {
return;
}
if (node.matches(SELECTORS.DIV.ACTIVITY)) {
this.ac.processActivityNode(node);
} else if (node.matches(SELECTORS.DIV.BUTTON)) {
this.ui.bindLoadMoreButton(node);
} else if (node.matches(SELECTORS.DIV.MARKDOWN)) {
const entry = node.closest(SELECTORS.DIV.ACTIVITY);
if (entry) this.ac.processActivityNode(entry);
}
}
_processLoadOrReset() {
if (this.ac.currentLoadCount < this.config.options.targetLoadCount && this.ui.userPressed) {
this.ui.triggerLoadMore();
} else {
this.ac._resetLoadCount();
this.ui.resetUIState();
}
}
_isUrlAllowed() {
const allowedPatterns = Object.keys(this.URLS).filter(pattern => this.config.runOn[pattern]);
return allowedPatterns.some(pattern => {
const regex = new RegExp(this.URLS[pattern].replace('*', '.*'));
return regex.test(window.location.href);
});
}
}
class ActivityHandler {
constructor(config) {
this.currentLoadCount = 0;
this.config = config;
this.LINKED = { TRUE: 1, FALSE: 0, NONE: -1 };
const wrap = method => (node, reverse) => {
const res = method.call(this, node);
return reverse ? !res : res;
};
const handlers = {
uncommented: this._evaluateUncommentedRemoval,
unliked: this._evaluateUnlikedRemoval,
text: this._evaluateTextRemoval,
images: this._evaluateImageRemoval,
gifs: this._evaluateGifRemoval,
videos: this._evaluateVideoRemoval,
containsStrings: this._evaluateStringRemoval
};
this.CONDITIONS_MAP = new Map(
Object.entries(handlers).map(
([name, method]) => [name, wrap(method)]
)
);
}
processActivityNode(node) {
const { options: { reverseConditions, linkedConditions } } = this.config;
this.linkedConditionsFlat = linkedConditions.flat();
const linkedResult = this._evaluateLinkedConditions(node);
const shouldRemove = reverseConditions
? this._evaluateReverseConditions(node, linkedResult)
: this._evaluateNormalConditions(node, linkedResult);
shouldRemove ? node.remove() : this.currentLoadCount++;
}
_evaluateLinkedConditions(node) {
const { options: { linkedConditions } } = this.config;
if (this.linkedConditionsFlat.length === 0) {
return this.LINKED.NONE;
}
const lists = this._extractLinkedConditions(linkedConditions);
const results = lists.map(list => this._evaluateConditionList(node, list));
const hasTrue = results.some(Boolean);
const hasFalse = results.some(r => !r);
return hasTrue && (!this.config.options.reverseConditions || !hasFalse)
? this.LINKED.TRUE
: this.LINKED.FALSE;
}
_evaluateReverseConditions(node, linkedResult) {
const { options: { reverseConditions } } = this.config;
const results = this._getActiveConditionFunctions().map(fn => fn(node, reverseConditions));
return linkedResult !== this.LINKED.FALSE
&& !results.includes(false)
&& (linkedResult === this.LINKED.TRUE || results.includes(true));
}
_evaluateNormalConditions(node, linkedResult) {
const { options: { reverseConditions } } = this.config;
const anyMatch = this._getActiveConditionFunctions().some(fn => fn(node, reverseConditions));
return linkedResult === this.LINKED.TRUE || anyMatch;
}
_getActiveConditionFunctions() {
const { remove } = this.config;
return [...this.CONDITIONS_MAP]
.filter(([name]) => {
if (this.linkedConditionsFlat.includes(name)) return false;
const cfg = remove[name];
return cfg === true || (Array.isArray(cfg) && cfg.flat().length > 0);
})
.map(([, fn]) => fn);
}
_evaluateConditionList(node, list) {
const { options: { reverseConditions } } = this.config;
return reverseConditions
? list.some(cond => this.CONDITIONS_MAP.get(cond)(node, reverseConditions))
: list.every(cond => this.CONDITIONS_MAP.get(cond)(node, reverseConditions));
}
_extractLinkedConditions(linkedConditions) {
const isNested = linkedConditions.some(Array.isArray);
return isNested
? linkedConditions.map(c => Array.isArray(c) ? c : [c])
: [linkedConditions];
}
_evaluateStringRemoval(node) {
const { remove: { containsStrings }, options: { caseSensitive } } = this.config;
const matches = substr => {
const text = node.textContent;
return caseSensitive
? text.includes(substr)
: text.toLowerCase().includes(substr.toLowerCase());
};
return containsStrings.some(group =>
Array.isArray(group)
? group.every(matches)
: matches(group)
);
}
_evaluateTextRemoval(node) {
const hasTextClass =
node.classList.contains(SELECTORS.ACTIVITY.TEXT) || node.classList.contains(SELECTORS.ACTIVITY.MESSAGE);
return hasTextClass && !(
this._evaluateImageRemoval(node) ||
this._evaluateGifRemoval(node) ||
this._evaluateVideoRemoval(node)
);
}
_evaluateVideoRemoval(node) {
return node.querySelector(SELECTORS.CLASS.VIDEO) || node.querySelector(SELECTORS.SPAN.YOUTUBE);
}
_evaluateImageRemoval(node) {
const img = node.querySelector(SELECTORS.CLASS.IMAGE);
return img && !img.src.includes('.gif');
}
_evaluateGifRemoval(node) {
const img = node.querySelector(SELECTORS.CLASS.IMAGE);
return img && img.src.includes('.gif');
}
_evaluateUncommentedRemoval(node) {
const replies = node.querySelector(SELECTORS.DIV.REPLIES);
return !replies || !replies.querySelector(SELECTORS.SPAN.COUNT);
}
_evaluateUnlikedRemoval(node) {
const likes = node.querySelector(SELECTORS.DIV.LIKES);
return !likes || !likes.querySelector(SELECTORS.SPAN.COUNT);
}
_resetLoadCount() {
this.currentLoadCount = 0;
}
}
class UIHandler {
constructor() {
this.userPressed = true;
this.loadMoreButton = null;
this.cancelButton = null;
}
bindLoadMoreButton(button) {
this.loadMoreButton = button;
button.addEventListener('click', () => {
this.userPressed = true;
this._startScrollTrigger();
this._showCancelButton();
});
}
triggerLoadMore() {
this.loadMoreButton?.click();
}
resetUIState() {
this.userPressed = false;
this._hideCancelButton();
}
displayErrorMessage(message) {
if (!this.errorContainer) {
const style =
`position: fixed;` +
`bottom: 10px;` +
`right: 10px;` +
`z-index: 10000;` +
`background-color: rgba(255,0,0,0.85);` +
`color: #fff;` +
`padding: 12px 20px;` +
`border-radius: 4px;` +
`font: 1.4rem Roboto, sans-serif;` +
`box-shadow: 0 2px 6px rgba(0,0,0,0.3);`;
this.errorContainer = Object.assign(
document.createElement('div'),
{
textContent: message,
className: 'config-error-message',
}
);
this.errorContainer.setAttribute('style', style);
document.body.appendChild(this.errorContainer);
} else {
this.errorContainer.textContent = message;
this.errorContainer.style.display = 'block';
}
setTimeout(() => {
if (this.errorContainer) {
this.errorContainer.style.display = 'none';
}
}, 5000);
}
_createCancelButton() {
if (this.cancelButton) {
this.cancelButton.style.display = 'block';
return;
}
const style =
`position: fixed;` +
`bottom: 10px;` +
`right: 10px;` +
`z-index: 9999;` +
`line-height: 1.3;` +
`background-color: rgb(var(--color-background-blue-dark));` +
`color: rgb(var(--color-text-bright));` +
`font: 1.6rem Roboto, sans-serif;` +
`box-sizing: border-box;`;
this.cancelButton = document.createElement('button');
this.cancelButton.textContent = 'Cancel';
this.cancelButton.className = 'cancel-button';
this.cancelButton.setAttribute('style', style);
this.cancelButton.addEventListener('click', () => {
this.userPressed = false;
this.cancelButton.style.display = 'none';
});
document.body.appendChild(this.cancelButton);
}
_showCancelButton() {
if (this.cancelButton) {
this.cancelButton.style.display = 'block';
} else {
this._createCancelButton();
}
}
_hideCancelButton() {
if (this.cancelButton) {
this.cancelButton.style.display = 'none';
}
}
_startScrollTrigger() {
const event = new Event('scroll', { bubbles: true });
const interval = setInterval(() => {
this.userPressed
? window.dispatchEvent(event)
: clearInterval(interval);
}, 100);
}
}
class ConfigValidator {
constructor(config) {
this.config = config;
this.errors = [];
}
validateConfig() {
this._validatePositiveInteger('options.targetLoadCount');
this._validateStringArray('remove.containsStrings');
this._validateStringArray('options.linkedConditions');
this._validateLinkedConditions();
this._validateBooleanSettings([
'remove.uncommented',
'remove.unliked',
'remove.text',
'remove.images',
'remove.gifs',
'remove.videos',
'options.caseSensitive',
'options.reverseConditions',
'runOn.home',
'runOn.social',
'runOn.profile',
'runOn.guestHome'
]);
if (this.errors.length) {
throw new Error(`Anilist Activity Feed Filter: Script disabled due to configuration errors: ${this.errors.join(', ')}`);
}
}
_validateLinkedConditions() {
const linked = this._flattenArray(this._getConfigValue('options.linkedConditions'));
const allowed = ['uncommented', 'unliked', 'text', 'images', 'gifs', 'videos', 'containsStrings'];
if (linked.some(cond => !allowed.includes(cond))) {
this.errors.push(`options.linkedConditions should only contain: ${allowed.join(', ')}`);
}
}
_validateBooleanSettings(paths) {
paths.forEach(path => {
if (typeof this._getConfigValue(path) !== 'boolean') {
this.errors.push(`${path} should be a boolean`);
}
});
}
_validateStringArray(path) {
const value = this._getConfigValue(path);
if (!Array.isArray(value)) {
this.errors.push(`${path} should be an array`);
} else if (!this._flattenArray(value).every(item => typeof item === 'string')) {
this.errors.push(`${path} should only contain strings`);
}
}
_validatePositiveInteger(path) {
const value = this._getConfigValue(path);
if (!Number.isInteger(value) || value <= 0) {
this.errors.push(`${path} should be a positive non-zero integer`);
}
}
_getConfigValue(path) {
return path.split('.').reduce((obj, key) => obj[key], this.config);
}
_flattenArray(arr) {
return arr.reduce((acc, val) => acc.concat(Array.isArray(val) ? this._flattenArray(val) : val), []);
}
}
const SELECTORS = {
DIV: {
BUTTON: 'div.load-more',
ACTIVITY: 'div.activity-entry',
REPLIES: 'div.action.replies',
LIKES: 'div.action.likes',
MARKDOWN: 'div.markdown'
},
SPAN: {
COUNT: 'span.count',
YOUTUBE: 'span.youtube',
},
ACTIVITY: {
TEXT: 'activity-text',
MESSAGE: 'activity-message',
},
CLASS: {
IMAGE: 'img',
VIDEO: 'video',
},
};
function initializeApp() {
const uiHandler = new UIHandler();
try {
new ConfigValidator(config).validateConfig();
} catch (error) {
uiHandler.displayErrorMessage(error.message);
return;
}
const activityHandler = new ActivityHandler(config);
const mainApp = new MainApp(activityHandler, uiHandler, config);
mainApp.initializeObserver();
}
initializeApp();