mirror of
https://github.com/CompeyDev/fxtwitter-docker.git
synced 2025-04-06 19:10:54 +01:00
347 lines
12 KiB
TypeScript
347 lines
12 KiB
TypeScript
import { Constants } from './constants';
|
|
import { fetchUsingGuest } from './fetch';
|
|
import { linkFixer } from './linkFixer';
|
|
import { colorFromPalette } from './palette';
|
|
import { renderCard } from './card';
|
|
import { handleQuote } from './quote';
|
|
import { sanitizeText } from './utils';
|
|
import { Strings } from './strings';
|
|
import { handleMosaic } from './mosaic';
|
|
|
|
export const returnError = (error: string): StatusResponse => {
|
|
return {
|
|
text: Strings.BASE_HTML.format({
|
|
lang: '',
|
|
headers: [
|
|
`<meta content="${Constants.BRANDING_NAME}" property="og:title"/>`,
|
|
`<meta content="${error}" property="og:description"/>`
|
|
].join('')
|
|
})
|
|
};
|
|
};
|
|
|
|
export const handleStatus = async (
|
|
event: FetchEvent,
|
|
status: string,
|
|
mediaNumber?: number,
|
|
userAgent?: string,
|
|
flags?: InputFlags
|
|
): Promise<StatusResponse> => {
|
|
console.log('Direct?', flags?.direct);
|
|
const conversation = await fetchUsingGuest(status, event);
|
|
|
|
const tweet = conversation?.globalObjects?.tweets?.[status] || {};
|
|
/* With v2 conversation API we re-add the user object ot the tweet because
|
|
Twitter stores it separately in the conversation API. This is to consolidate
|
|
it in case a user appears multiple times in a thread. */
|
|
tweet.user = conversation?.globalObjects?.users?.[tweet.user_id_str] || {};
|
|
|
|
/* Try to deep link to mobile apps, just like Twitter does.
|
|
No idea if this actually works.*/
|
|
let headers: string[] = [
|
|
`<meta property="fb:app_id" content="2231777543"/>`,
|
|
`<meta content="twitter://status?id=${status}" property="al:ios:url"/>`,
|
|
`<meta content="333903271" property="al:ios:app_store_id"/>`,
|
|
`<meta content="Twitter" property="al:ios:app_name"/>`,
|
|
`<meta content="twitter://status?id=${status}" property="al:android:url"/>`,
|
|
`<meta content="com.twitter.android" property="al:android:package"/>`,
|
|
`<meta content="Twitter" property="al:android:app_name"/>`
|
|
];
|
|
|
|
let redirectMedia = '';
|
|
|
|
/* Fallback for if Tweet did not load */
|
|
if (typeof tweet.full_text === 'undefined') {
|
|
console.log('Invalid status, got tweet ', tweet, ' conversation ', conversation);
|
|
|
|
/* We've got timeline instructions, so the Tweet is probably private */
|
|
if (conversation.timeline?.instructions?.length > 0) {
|
|
return returnError(Strings.ERROR_PRIVATE);
|
|
}
|
|
|
|
/* {"errors":[{"code":34,"message":"Sorry, that page does not exist."}]} */
|
|
if (conversation.errors?.[0]?.code === 34) {
|
|
return returnError(Strings.ERROR_TWEET_NOT_FOUND);
|
|
}
|
|
|
|
/* Tweets object is completely missing, smells like API failure */
|
|
if (typeof conversation?.globalObjects?.tweets === 'undefined') {
|
|
return returnError(Strings.ERROR_API_FAIL);
|
|
}
|
|
|
|
/* If we have no idea what happened then just return API error */
|
|
return returnError(Strings.ERROR_API_FAIL);
|
|
}
|
|
|
|
let text = tweet.full_text;
|
|
let engagementText = '';
|
|
const user = tweet.user;
|
|
const screenName = user?.screen_name || '';
|
|
const name = user?.name || '';
|
|
|
|
let mediaList = Array.from(
|
|
tweet.extended_entities?.media || tweet.entities?.media || []
|
|
);
|
|
|
|
let authorText = Strings.DEFAULT_AUTHOR_TEXT;
|
|
|
|
if (tweet.favorite_count > 0 || tweet.retweet_count > 0 || tweet.reply_count > 0) {
|
|
authorText = '';
|
|
if (tweet.reply_count > 0) {
|
|
authorText += `${tweet.reply_count} 💬 `;
|
|
}
|
|
if (tweet.retweet_count > 0) {
|
|
authorText += `${tweet.retweet_count} 🔁 `;
|
|
}
|
|
if (tweet.favorite_count > 0) {
|
|
authorText += `${tweet.favorite_count} ❤️ `;
|
|
}
|
|
authorText = authorText.trim();
|
|
|
|
// engagementText has less spacing than authorText, also Telegram interprets the other heart as emoji
|
|
engagementText = authorText.replace(/ /g, ' ');
|
|
}
|
|
|
|
text = linkFixer(tweet, text);
|
|
|
|
/* Cards are used by polls and non-Twitter video embeds */
|
|
if (tweet.card) {
|
|
let cardRender = await renderCard(tweet.card, headers, userAgent);
|
|
|
|
if (cardRender === 'EMBED_CARD') {
|
|
authorText = encodeURIComponent(text);
|
|
} else {
|
|
text += cardRender;
|
|
}
|
|
}
|
|
|
|
/* Trying to uncover a quote tweet referenced by this tweet */
|
|
let quoteTweetMaybe =
|
|
conversation.globalObjects?.tweets?.[tweet.quoted_status_id_str || '0'] || null;
|
|
|
|
if (quoteTweetMaybe) {
|
|
/* Populate quote tweet user from globalObjects */
|
|
quoteTweetMaybe.user =
|
|
conversation?.globalObjects?.users?.[quoteTweetMaybe.user_id_str] || {};
|
|
const quoteText = handleQuote(quoteTweetMaybe);
|
|
|
|
console.log('quoteText', quoteText);
|
|
|
|
if (quoteText) {
|
|
text += `\n${quoteText}`;
|
|
}
|
|
|
|
/* This code handles checking the quote tweet for media.
|
|
We'll embed a quote tweet's media if the linked tweet does not have any. */
|
|
if (
|
|
mediaList.length === 0 &&
|
|
(quoteTweetMaybe.extended_entities?.media?.length ||
|
|
quoteTweetMaybe.entities?.media?.length ||
|
|
0) > 0
|
|
) {
|
|
console.log(
|
|
`No media in main tweet, let's try embedding the quote tweet's media instead!`
|
|
);
|
|
mediaList = Array.from(
|
|
quoteTweetMaybe.extended_entities?.media || quoteTweetMaybe.entities?.media || []
|
|
);
|
|
|
|
console.log('updated mediaList', mediaList);
|
|
}
|
|
}
|
|
|
|
/* No media was found, but that's OK because we can still enrichen the Tweet
|
|
with a profile picture and color-matched embed in Discord! */
|
|
if (mediaList.length === 0) {
|
|
console.log('No media');
|
|
let palette = user?.profile_image_extensions_media_color?.palette;
|
|
let colorOverride: string = Constants.DEFAULT_COLOR;
|
|
|
|
// for loop for palettes
|
|
if (palette) {
|
|
colorOverride = colorFromPalette(palette);
|
|
}
|
|
|
|
headers.push(
|
|
`<meta content="${colorOverride}" property="theme-color"/>`,
|
|
`<meta property="og:site_name" content="${Constants.BRANDING_NAME}"/>`,
|
|
// Use a slightly higher resolution image for profile pics
|
|
`<meta property="og:image" content="${user?.profile_image_url_https.replace(
|
|
'_normal',
|
|
'_200x200'
|
|
)}"/>`,
|
|
`<meta name="twitter:card" content="tweet"/>`,
|
|
`<meta name="twitter:title" content="${name} (@${screenName})"/>`,
|
|
`<meta name="twitter:image" content="0"/>`,
|
|
`<meta name="twitter:creator" content="@${name}"/>`,
|
|
`<meta content="${sanitizeText(text)}" property="og:description"/>`
|
|
);
|
|
} else {
|
|
console.log('Media available');
|
|
let firstMedia = mediaList[0];
|
|
|
|
/* Try grabbing media color palette */
|
|
let palette = firstMedia?.ext_media_color?.palette;
|
|
let colorOverride: string = Constants.DEFAULT_COLOR;
|
|
let pushedCardType = false;
|
|
|
|
if (palette) {
|
|
colorOverride = colorFromPalette(palette);
|
|
}
|
|
|
|
/* theme-color is used by discord to style the embed.
|
|
|
|
We take full advantage of that!*/
|
|
headers.push(`<meta content="${colorOverride}" property="theme-color"/>`);
|
|
|
|
/* Inline helper function for handling media */
|
|
const processMedia = (media: TweetMedia) => {
|
|
if (media.type === 'photo') {
|
|
if (flags?.direct && typeof media.media_url_https === 'string') {
|
|
redirectMedia = media.media_url_https;
|
|
return;
|
|
}
|
|
|
|
headers.push(
|
|
`<meta name="twitter:image" content="${media.media_url_https}"/>`,
|
|
`<meta property="og:image" content="${media.media_url_https}"/>`
|
|
);
|
|
|
|
if (media.original_info?.width && media.original_info?.height) {
|
|
headers.push(
|
|
`<meta name="twitter:image:width" content="${media.original_info.width}"/>`,
|
|
`<meta name="twitter:image:height" content="${media.original_info.height}"/>`,
|
|
`<meta name="og:image:width" content="${media.original_info.width}"/>`,
|
|
`<meta name="og:image:height" content="${media.original_info.height}"/>`
|
|
);
|
|
}
|
|
|
|
if (!pushedCardType) {
|
|
headers.push(`<meta name="twitter:card" content="summary_large_image"/>`);
|
|
pushedCardType = true;
|
|
}
|
|
} else if (media.type === 'video' || media.type === 'animated_gif') {
|
|
// Find the variant with the highest bitrate
|
|
let bestVariant = media.video_info?.variants?.reduce?.((a, b) =>
|
|
(a.bitrate ?? 0) > (b.bitrate ?? 0) ? a : b
|
|
);
|
|
|
|
if (flags?.direct && bestVariant?.url) {
|
|
console.log(`Redirecting to ${bestVariant.url}`);
|
|
redirectMedia = bestVariant.url;
|
|
return;
|
|
}
|
|
|
|
headers.push(`<meta name="twitter:image" content="${media.media_url_https}"/>`);
|
|
|
|
/* On Discord we have to use the author field in order to get the tweet text
|
|
to display on videos. This length is limited, however, and if there is too
|
|
much text Discord will refuse to display it at all, so we trim down as much
|
|
as the client will display. */
|
|
if (userAgent && userAgent?.indexOf?.('Discord') > -1) {
|
|
text = text.substr(0, 179);
|
|
}
|
|
|
|
authorText = encodeURIComponent(text);
|
|
|
|
headers.push(
|
|
`<meta name="twitter:card" content="player"/>`,
|
|
`<meta name="twitter:player:stream" content="${bestVariant?.url}"/>`,
|
|
`<meta name="twitter:player:stream:content_type" content="${bestVariant?.content_type}"/>`,
|
|
`<meta name="twitter:player:height" content="${media.original_info.height}"/>`,
|
|
`<meta name="twitter:player:width" content="${media.original_info.width}"/>`,
|
|
`<meta name="og:video" content="${bestVariant?.url}"/>`,
|
|
`<meta name="og:video:secure_url" content="${bestVariant?.url}"/>`,
|
|
`<meta name="og:video:height" content="${media.original_info.height}"/>`,
|
|
`<meta name="og:video:width" content="${media.original_info.width}"/>`,
|
|
`<meta name="og:video:type" content="${bestVariant?.content_type}"/>`
|
|
);
|
|
}
|
|
};
|
|
|
|
let actualMediaNumber = 0;
|
|
let renderedMosaic = false;
|
|
|
|
console.log('mediaNumber', mediaNumber);
|
|
console.log('mediaList length', mediaList.length);
|
|
|
|
/* You can specify a specific photo in the URL and we'll pull the correct one,
|
|
otherwise it falls back to first */
|
|
if (
|
|
typeof mediaNumber !== 'undefined' &&
|
|
typeof mediaList[mediaNumber - 1] !== 'undefined'
|
|
) {
|
|
console.log(`Media ${mediaNumber} found`);
|
|
actualMediaNumber = mediaNumber - 1;
|
|
processMedia(mediaList[actualMediaNumber]);
|
|
} else if (mediaList.length === 1 || (userAgent?.indexOf?.('Telegram') || '') > -1) {
|
|
console.log(`Media ${mediaNumber} not found, ${mediaList.length} total`);
|
|
processMedia(firstMedia);
|
|
// Telegram hates Mosaic media for some reason
|
|
} else if (mediaList.length > 1 && userAgent?.indexOf('Telegram') === -1) {
|
|
console.log('Handling mosaic');
|
|
processMedia(await handleMosaic(mediaList));
|
|
renderedMosaic = true;
|
|
}
|
|
|
|
if (flags?.direct && redirectMedia) {
|
|
let response = Response.redirect(redirectMedia, 302);
|
|
console.log(response);
|
|
return { response: response };
|
|
}
|
|
|
|
if (mediaList.length > 1 && !renderedMosaic) {
|
|
let photoCounter = Strings.PHOTO_COUNT.format({
|
|
number: actualMediaNumber + 1,
|
|
total: mediaList.length
|
|
});
|
|
|
|
authorText =
|
|
authorText === Strings.DEFAULT_AUTHOR_TEXT
|
|
? photoCounter
|
|
: `${authorText} ― ${photoCounter}`;
|
|
|
|
let siteName = `${Constants.BRANDING_NAME} - ${photoCounter}`;
|
|
|
|
if (engagementText) {
|
|
siteName = `${Constants.BRANDING_NAME} - ${engagementText} - ${photoCounter}`;
|
|
}
|
|
|
|
headers.push(`<meta property="og:site_name" content="${siteName}"/>`);
|
|
} else {
|
|
headers.push(
|
|
`<meta property="og:site_name" content="${Constants.BRANDING_NAME}"/>`
|
|
);
|
|
}
|
|
|
|
headers.push(
|
|
`<meta content="${name} (@${screenName})" property="og:title"/>`,
|
|
`<meta content="${sanitizeText(text)}" property="og:description"/>`
|
|
);
|
|
}
|
|
|
|
/* Special reply handling if authorText is not overriden */
|
|
if (tweet.in_reply_to_screen_name && authorText === 'Twitter') {
|
|
authorText = `↪ Replying to @${tweet.in_reply_to_screen_name}`;
|
|
}
|
|
|
|
/* The additional oembed is pulled by Discord to enable improved embeds.
|
|
Telegram does not use this. */
|
|
headers.push(
|
|
`<link rel="alternate" href="${Constants.HOST_URL}/owoembed?text=${encodeURIComponent(
|
|
authorText
|
|
)}&status=${encodeURIComponent(status)}&author=${encodeURIComponent(
|
|
user?.screen_name || ''
|
|
)}" type="application/json+oembed" title="${name}">`
|
|
);
|
|
|
|
/* When dealing with a Tweet of unknown lang, fall back to en */
|
|
let lang = tweet.lang === 'unk' ? 'en' : tweet.lang || 'en';
|
|
|
|
return {
|
|
text: Strings.BASE_HTML.format({
|
|
lang: `lang="${lang}"`,
|
|
headers: headers.join('')
|
|
})
|
|
};
|
|
};
|