+import { Picker } from "emoji-mart";
import emojiShortName from "emoji-short-name";
import {
BlockCommunityResponse,
BlockPersonResponse,
+ CommentAggregates,
+ Comment as CommentI,
+ CommentReplyView,
CommentReportView,
+ CommentSortType,
CommentView,
- CommunityBlockView,
+ CommunityModeratorView,
CommunityView,
+ CustomEmojiView,
GetSiteMetadata,
GetSiteResponse,
+ Language,
LemmyHttp,
- LemmyWebsocket,
- ListingType,
MyUserInfo,
- PersonBlockView,
- PersonSafe,
- PersonViewSafe,
+ Person,
+ PersonMentionView,
+ PersonView,
PostReportView,
PostView,
+ PrivateMessageReportView,
PrivateMessageView,
RegistrationApplicationView,
Search,
SearchType,
SortType,
- UserOperation,
- WebSocketJsonResponse,
- WebSocketResponse,
} from "lemmy-js-client";
-import markdown_it from "markdown-it";
+import { default as MarkdownIt } from "markdown-it";
import markdown_it_container from "markdown-it-container";
+import markdown_it_emoji from "markdown-it-emoji/bare";
import markdown_it_footnote from "markdown-it-footnote";
import markdown_it_html5_embed from "markdown-it-html5-embed";
import markdown_it_sub from "markdown-it-sub";
import markdown_it_sup from "markdown-it-sup";
+import Renderer from "markdown-it/lib/renderer";
+import Token from "markdown-it/lib/token";
import moment from "moment";
-import { Subscription } from "rxjs";
-import { delay, retryWhen, take } from "rxjs/operators";
import tippy from "tippy.js";
import Toastify from "toastify-js";
-import { httpBase } from "./env";
+import { getHttpBase } from "./env";
import { i18n, languages } from "./i18next";
-import {
- CommentNode as CommentNodeI,
- CommentSortType,
- DataType,
- IsoData,
-} from "./interfaces";
-import { UserService, WebSocketService } from "./services";
+import { CommentNodeI, DataType, IsoData, VoteType } from "./interfaces";
+import { HttpService, UserService } from "./services";
+import { RequestState } from "./services/HttpService";
-var Tribute: any;
+let Tribute: any;
if (isBrowser()) {
Tribute = require("tributejs");
}
-export const wsClient = new LemmyWebsocket();
-
export const favIconUrl = "/static/assets/icons/favicon.svg";
export const favIconPngUrl = "/static/assets/icons/apple-touch-icon.png";
// TODO
export const joinLemmyUrl = "https://join-lemmy.org";
export const donateLemmyUrl = `${joinLemmyUrl}/donate`;
export const docsUrl = `${joinLemmyUrl}/docs/en/index.html`;
-export const helpGuideUrl = `${joinLemmyUrl}/docs/en/about/guide.html`; // TODO find a way to redirect to the non-en folder
-export const markdownHelpUrl = `${helpGuideUrl}#using-markdown`;
-export const sortingHelpUrl = `${helpGuideUrl}#sorting`;
+export const helpGuideUrl = `${joinLemmyUrl}/docs/en/users/01-getting-started.html`; // TODO find a way to redirect to the non-en folder
+export const markdownHelpUrl = `${joinLemmyUrl}/docs/en/users/02-media.html`;
+export const sortingHelpUrl = `${joinLemmyUrl}/docs/en/users/03-votes-and-ranking.html`;
export const archiveTodayUrl = "https://archive.today";
export const ghostArchiveUrl = "https://ghostarchive.org";
export const webArchiveUrl = "https://web.archive.org";
export const elementUrl = "https://element.io";
export const postRefetchSeconds: number = 60 * 1000;
-export const fetchLimit = 20;
+export const fetchLimit = 40;
+export const trendingFetchLimit = 6;
export const mentionDropdownFetchLimit = 10;
+export const commentTreeMaxDepth = 8;
+export const markdownFieldCharacterLimit = 50000;
+export const maxUploadImages = 20;
+export const concurrentImageUpload = 4;
export const relTags = "noopener nofollow";
+export const emDash = "\u2014";
+
+export type ThemeColor =
+ | "primary"
+ | "secondary"
+ | "light"
+ | "dark"
+ | "success"
+ | "danger"
+ | "warning"
+ | "info"
+ | "blue"
+ | "indigo"
+ | "purple"
+ | "pink"
+ | "red"
+ | "orange"
+ | "yellow"
+ | "green"
+ | "teal"
+ | "cyan"
+ | "white"
+ | "gray"
+ | "gray-dark";
+
+export interface ErrorPageData {
+ error?: string;
+ adminMatrixIds?: string[];
+}
+
+const customEmojis: EmojiMartCategory[] = [];
+export let customEmojisLookup: Map<string, CustomEmojiView> = new Map<
+ string,
+ CustomEmojiView
+>();
+
const DEFAULT_ALPHABET =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
return alphabet.charAt(Math.floor(Math.random() * alphabet.length));
}
+export function getIdFromString(id?: string): number | undefined {
+ return id && id !== "0" && !Number.isNaN(Number(id)) ? Number(id) : undefined;
+}
+
+export function getPageFromString(page?: string): number {
+ return page && !Number.isNaN(Number(page)) ? Number(page) : 1;
+}
+
export function randomStr(
idDesiredLength = 20,
alphabet = DEFAULT_ALPHABET
.join("");
}
-export function wsJsonToRes<ResponseType>(
- msg: WebSocketJsonResponse<ResponseType>
-): WebSocketResponse<ResponseType> {
- return {
- op: wsUserOp(msg),
- data: msg.data,
- };
-}
-
-export function wsUserOp(msg: any): UserOperation {
- let opStr: string = msg.op;
- return UserOperation[opStr];
-}
-
-export const md = new markdown_it({
- html: true,
- linkify: true,
- typographer: true,
-})
- .use(markdown_it_sub)
- .use(markdown_it_sup)
- .use(markdown_it_footnote)
- .use(markdown_it_html5_embed, {
- html5embed: {
- useImageSyntax: true, // Enables video/audio embed with ![]() syntax (default)
- attributes: {
- audio: 'controls preload="metadata"',
- video:
- 'width="100%" max-height="100%" controls loop preload="metadata"',
- },
- },
- })
- .use(markdown_it_container, "spoiler", {
- validate: function (params: any) {
- return params.trim().match(/^spoiler\s+(.*)$/);
+const html5EmbedConfig = {
+ html5embed: {
+ useImageSyntax: true, // Enables video/audio embed with ![]() syntax (default)
+ attributes: {
+ audio: 'controls preload="metadata"',
+ video: 'width="100%" max-height="100%" controls loop preload="metadata"',
},
+ },
+};
- render: function (tokens: any, idx: any) {
- var m = tokens[idx].info.trim().match(/^spoiler\s+(.*)$/);
+const spoilerConfig = {
+ validate: (params: string) => {
+ return params.trim().match(/^spoiler\s+(.*)$/);
+ },
- if (tokens[idx].nesting === 1) {
- // opening tag
- return `<details><summary> ${md.utils.escapeHtml(m[1])} </summary>\n`;
- } else {
- // closing tag
- return "</details>\n";
- }
- },
- });
+ render: (tokens: any, idx: any) => {
+ var m = tokens[idx].info.trim().match(/^spoiler\s+(.*)$/);
+
+ if (tokens[idx].nesting === 1) {
+ // opening tag
+ return `<details><summary> ${md.utils.escapeHtml(m[1])} </summary>\n`;
+ } else {
+ // closing tag
+ return "</details>\n";
+ }
+ },
+};
+
+export let md: MarkdownIt = new MarkdownIt();
+
+export let mdNoImages: MarkdownIt = new MarkdownIt();
export function hotRankComment(comment_view: CommentView): number {
return hotRank(comment_view.counts.score, comment_view.comment.published);
export function hotRank(score: number, timeStr: string): number {
// Rank = ScaleFactor * sign(Score) * log(1 + abs(Score)) / (Time + 2)^Gravity
- let date: Date = new Date(timeStr + "Z"); // Add Z to convert from UTC date
- let now: Date = new Date();
- let hoursElapsed: number = (now.getTime() - date.getTime()) / 36e5;
+ const date: Date = new Date(timeStr + "Z"); // Add Z to convert from UTC date
+ const now: Date = new Date();
+ const hoursElapsed: number = (now.getTime() - date.getTime()) / 36e5;
- let rank =
- (10000 * Math.log10(Math.max(1, 3 + score))) /
+ const rank =
+ (10000 * Math.log10(Math.max(1, 3 + Number(score)))) /
Math.pow(hoursElapsed + 2, 1.8);
// console.log(`Comment: ${comment.content}\nRank: ${rank}\nScore: ${comment.score}\nHours: ${hoursElapsed}`);
return { __html: md.render(text) };
}
-export function getUnixTime(text: string): number {
+export function mdToHtmlNoImages(text: string) {
+ return { __html: mdNoImages.render(text) };
+}
+
+export function mdToHtmlInline(text: string) {
+ return { __html: md.renderInline(text) };
+}
+
+export function getUnixTime(text?: string): number | undefined {
return text ? new Date(text).getTime() / 1000 : undefined;
}
-export function futureDaysToUnixTime(days: number): number {
+export function futureDaysToUnixTime(days?: number): number | undefined {
return days
? Math.trunc(
new Date(Date.now() + 1000 * 60 * 60 * 24 * days).getTime() / 1000
}
export function canMod(
- myUserInfo: MyUserInfo,
- modIds: number[],
creator_id: number,
+ mods?: CommunityModeratorView[],
+ admins?: PersonView[],
+ myUserInfo = UserService.Instance.myUserInfo,
onSelf = false
): boolean {
// You can do moderator actions only on the mods added after you.
+ let adminsThenMods =
+ admins
+ ?.map(a => a.person.id)
+ .concat(mods?.map(m => m.moderator.id) ?? []) ?? [];
+
if (myUserInfo) {
- let yourIndex = modIds.findIndex(
+ const myIndex = adminsThenMods.findIndex(
id => id == myUserInfo.local_user_view.person.id
);
- if (yourIndex == -1) {
+ if (myIndex == -1) {
return false;
} else {
// onSelf +1 on mod actions not for yourself, IE ban, remove, etc
- modIds = modIds.slice(0, yourIndex + (onSelf ? 0 : 1));
- return !modIds.includes(creator_id);
+ adminsThenMods = adminsThenMods.slice(0, myIndex + (onSelf ? 0 : 1));
+ return !adminsThenMods.includes(creator_id);
}
} else {
return false;
}
}
-export function isMod(modIds: number[], creator_id: number): boolean {
- return modIds.includes(creator_id);
+export function canAdmin(
+ creatorId: number,
+ admins?: PersonView[],
+ myUserInfo = UserService.Instance.myUserInfo,
+ onSelf = false
+): boolean {
+ return canMod(creatorId, undefined, admins, myUserInfo, onSelf);
+}
+
+export function isMod(
+ creatorId: number,
+ mods?: CommunityModeratorView[]
+): boolean {
+ return mods?.map(m => m.moderator.id).includes(creatorId) ?? false;
+}
+
+export function amMod(
+ mods?: CommunityModeratorView[],
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ return myUserInfo ? isMod(myUserInfo.local_user_view.person.id, mods) : false;
+}
+
+export function isAdmin(creatorId: number, admins?: PersonView[]): boolean {
+ return admins?.map(a => a.person.id).includes(creatorId) ?? false;
+}
+
+export function amAdmin(myUserInfo = UserService.Instance.myUserInfo): boolean {
+ return myUserInfo?.local_user_view.person.admin ?? false;
+}
+
+export function amCommunityCreator(
+ creator_id: number,
+ mods?: CommunityModeratorView[],
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ const myId = myUserInfo?.local_user_view.person.id;
+ // Don't allow mod actions on yourself
+ return myId == mods?.at(0)?.moderator.id && myId != creator_id;
+}
+
+export function amSiteCreator(
+ creator_id: number,
+ admins?: PersonView[],
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ const myId = myUserInfo?.local_user_view.person.id;
+ return myId == admins?.at(0)?.person.id && myId != creator_id;
+}
+
+export function amTopMod(
+ mods: CommunityModeratorView[],
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ return mods.at(0)?.moderator.id == myUserInfo?.local_user_view.person.id;
}
const imageRegex = /(http)?s?:?(\/\/[^"']*\.(?:jpg|jpeg|gif|png|svg|webp))/;
}
export function communityRSSUrl(actorId: string, sort: string): string {
- let url = new URL(actorId);
+ const url = new URL(actorId);
return `${url.origin}/feeds${url.pathname}.xml?sort=${sort}`;
}
export function validEmail(email: string) {
- let re =
+ const re =
/^(([^\s"(),.:;<>@[\\\]]+(\.[^\s"(),.:;<>@[\\\]]+)*)|(".+"))@((\[(?:\d{1,3}\.){3}\d{1,3}])|(([\dA-Za-z\-]+\.)+[A-Za-z]{2,}))$/;
return re.test(String(email).toLowerCase());
}
return str.charAt(0).toUpperCase() + str.slice(1);
}
-export function routeSortTypeToEnum(sort: string): SortType {
- return SortType[sort];
-}
-
-export function listingTypeFromNum(type_: number): ListingType {
- return Object.values(ListingType)[type_];
-}
-
-export function sortTypeFromNum(type_: number): SortType {
- return Object.values(SortType)[type_];
-}
-
-export function routeListingTypeToEnum(type: string): ListingType {
- return ListingType[type];
-}
-
-export function routeDataTypeToEnum(type: string): DataType {
- return DataType[capitalizeFirstLetter(type)];
-}
-
-export function routeSearchTypeToEnum(type: string): SearchType {
- return SearchType[type];
-}
-
export async function getSiteMetadata(url: string) {
- let form: GetSiteMetadata = {
- url,
- };
- let client = new LemmyHttp(httpBase);
+ const form: GetSiteMetadata = { url };
+ const client = new LemmyHttp(getHttpBase());
return client.getSiteMetadata(form);
}
-export function debounce(func: any, wait = 1000, immediate = false) {
+export function getDataTypeString(dt: DataType) {
+ return dt === DataType.Post ? "Post" : "Comment";
+}
+
+export function debounce<T extends any[], R>(
+ func: (...e: T) => R,
+ wait = 1000,
+ immediate = false
+) {
// 'private' variable for instance
// The returned function will be able to reference this due to closure.
// Each call to the returned function will share this common timer.
- let timeout: any;
+ let timeout: NodeJS.Timeout | null;
// Calling debounce returns a new anonymous function
return function () {
// reference the context and args for the setTimeout function
- var args = arguments;
+ const args = arguments;
// Should the function be called now? If immediate is true
// and not already in a timeout then the answer is: Yes
- var callNow = immediate && !timeout;
+ const callNow = immediate && !timeout;
- // This is the basic debounce behaviour where you can call this
+ // This is the basic debounce behavior where you can call this
// function several times, but it will only execute once
// [before or after imposing a delay].
// Each time the returned function is called, the timer starts over.
- clearTimeout(timeout);
+ clearTimeout(timeout ?? undefined);
// Set the new timeout
timeout = setTimeout(function () {
// Immediate mode and no wait timer? Execute the function..
if (callNow) func.apply(this, args);
- };
+ } as (...e: T) => R;
}
-export function getLanguages(override?: string): string[] {
- let myUserInfo = UserService.Instance.myUserInfo;
- let lang =
- override ||
- (myUserInfo?.local_user_view.local_user.lang
- ? myUserInfo.local_user_view.local_user.lang
- : "browser");
+export function getLanguages(
+ override?: string,
+ myUserInfo = UserService.Instance.myUserInfo
+): string[] {
+ const myLang = myUserInfo?.local_user_view.local_user.interface_language;
+ const lang = override || myLang || "browser";
if (lang == "browser" && isBrowser()) {
return getBrowserLanguages();
function getBrowserLanguages(): string[] {
// Intersect lemmy's langs, with the browser langs
- let langs = languages ? languages.map(l => l.code) : ["en"];
+ const langs = languages ? languages.map(l => l.code) : ["en"];
// NOTE, mobile browsers seem to be missing this list, so append en
- let allowedLangs = navigator.languages
+ const allowedLangs = navigator.languages
.concat("en")
.filter(v => langs.includes(v));
return allowedLangs;
theme = "darkly";
}
- let themeList = await fetchThemeList();
+ const themeList = await fetchThemeList();
// Unload all the other themes
for (var i = 0; i < themeList.length; i++) {
- let styleSheet = document.getElementById(themeList[i]);
+ const styleSheet = document.getElementById(themeList[i]);
if (styleSheet) {
styleSheet.setAttribute("disabled", "disabled");
}
document.getElementById("default-dark")?.setAttribute("disabled", "disabled");
// Load the theme dynamically
- let cssLoc = `/css/themes/${theme}.css`;
+ const cssLoc = `/css/themes/${theme}.css`;
loadCss(theme, cssLoc);
- document.getElementById(theme).removeAttribute("disabled");
+ document.getElementById(theme)?.removeAttribute("disabled");
}
export function loadCss(id: string, loc: string) {
return ret;
}
-export function showAvatars(): boolean {
- return (
- UserService.Instance.myUserInfo?.local_user_view.local_user.show_avatars ||
- !UserService.Instance.myUserInfo
- );
+export function showAvatars(
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ return myUserInfo?.local_user_view.local_user.show_avatars ?? true;
}
-export function showScores(): boolean {
- return (
- UserService.Instance.myUserInfo?.local_user_view.local_user.show_scores ||
- !UserService.Instance.myUserInfo
- );
+export function showScores(
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ return myUserInfo?.local_user_view.local_user.show_scores ?? true;
}
export function isCakeDay(published: string): boolean {
// moment(undefined) or moment.utc(undefined) returns the current date/time
// moment(null) or moment.utc(null) returns null
- const createDate = moment.utc(published || null).local();
+ const createDate = moment.utc(published).local();
const currentDate = moment(new Date());
return (
);
}
-export function toast(text: string, background = "success") {
+export function toast(text: string, background: ThemeColor = "success") {
if (isBrowser()) {
- let backgroundColor = `var(--${background})`;
+ const backgroundColor = `var(--${background})`;
Toastify({
text: text,
backgroundColor: backgroundColor,
gravity: "bottom",
position: "left",
+ duration: 5000,
}).showToast();
}
}
-export function pictrsDeleteToast(
- clickToDeleteText: string,
- deletePictureText: string,
- deleteUrl: string
-) {
+export function pictrsDeleteToast(filename: string, deleteUrl: string) {
if (isBrowser()) {
- let backgroundColor = `var(--light)`;
- let toast = Toastify({
+ const clickToDeleteText = i18n.t("click_to_delete_picture", { filename });
+ const deletePictureText = i18n.t("picture_deleted", {
+ filename,
+ });
+ const failedDeletePictureText = i18n.t("failed_to_delete_picture", {
+ filename,
+ });
+
+ const backgroundColor = `var(--light)`;
+
+ const toast = Toastify({
text: clickToDeleteText,
backgroundColor: backgroundColor,
gravity: "top",
duration: 10000,
onClick: () => {
if (toast) {
- window.location.replace(deleteUrl);
- alert(deletePictureText);
- toast.hideToast();
+ fetch(deleteUrl).then(res => {
+ toast.hideToast();
+ if (res.ok === true) {
+ alert(deletePictureText);
+ } else {
+ alert(failedDeletePictureText);
+ }
+ });
}
},
close: true,
- }).showToast();
- }
-}
-
-interface NotifyInfo {
- name: string;
- icon?: string;
- link: string;
- body: string;
-}
-
-export function messageToastify(info: NotifyInfo, router: any) {
- if (isBrowser()) {
- let htmlBody = info.body ? md.render(info.body) : "";
- let backgroundColor = `var(--light)`;
+ });
- let toast = Toastify({
- text: `${htmlBody}<br />${info.name}`,
- avatar: info.icon ? info.icon : null,
- backgroundColor: backgroundColor,
- className: "text-dark",
- close: true,
- gravity: "top",
- position: "right",
- duration: 5000,
- escapeMarkup: false,
- onClick: () => {
- if (toast) {
- toast.hideToast();
- router.history.push(info.link);
- }
- },
- }).showToast();
+ toast.showToast();
}
}
-export function notifyPost(post_view: PostView, router: any) {
- let info: NotifyInfo = {
- name: post_view.community.name,
- icon: post_view.community.icon,
- link: `/post/${post_view.post.id}`,
- body: post_view.post.name,
- };
- notify(info, router);
-}
-
-export function notifyComment(comment_view: CommentView, router: any) {
- let info: NotifyInfo = {
- name: comment_view.creator.name,
- icon: comment_view.creator.avatar,
- link: `/post/${comment_view.post.id}/comment/${comment_view.comment.id}`,
- body: comment_view.comment.content,
- };
- notify(info, router);
-}
-
-export function notifyPrivateMessage(pmv: PrivateMessageView, router: any) {
- let info: NotifyInfo = {
- name: pmv.creator.name,
- icon: pmv.creator.avatar,
- link: `/inbox`,
- body: pmv.private_message.content,
- };
- notify(info, router);
-}
-
-function notify(info: NotifyInfo, router: any) {
- messageToastify(info, router);
-
- // TODO absolute nightmare bug, but notifs are currently broken.
- // Notification.new will try to do a browser fetch ???
-
- // if (Notification.permission !== "granted") Notification.requestPermission();
- // else {
- // var notification = new Notification(info.name, {
- // icon: info.icon,
- // body: info.body,
- // });
-
- // notification.onclick = (ev: Event): any => {
- // ev.preventDefault();
- // router.history.push(info.link);
- // };
- // }
-}
-
export function setupTribute() {
return new Tribute({
noMatchTemplate: function () {
{
trigger: ":",
menuItemTemplate: (item: any) => {
- let shortName = `:${item.original.key}:`;
+ const shortName = `:${item.original.key}:`;
return `${item.original.val} ${shortName}`;
},
selectTemplate: (item: any) => {
- return `${item.original.val}`;
+ const customEmoji = customEmojisLookup.get(
+ item.original.key
+ )?.custom_emoji;
+ if (customEmoji == undefined) return `${item.original.val}`;
+ else
+ return `![${customEmoji.alt_text}](${customEmoji.image_url} "${customEmoji.shortcode}")`;
},
- values: Object.entries(emojiShortName).map(e => {
- return { key: e[1], val: e[0] };
- }),
+ values: Object.entries(emojiShortName)
+ .map(e => {
+ return { key: e[1], val: e[0] };
+ })
+ .concat(
+ Array.from(customEmojisLookup.entries()).map(k => ({
+ key: k[0],
+ val: `<img class="icon icon-emoji" src="${k[1].custom_emoji.image_url}" title="${k[1].custom_emoji.shortcode}" alt="${k[1].custom_emoji.alt_text}" />`,
+ }))
+ ),
allowSpaces: false,
autocompleteMode: true,
// TODO
{
trigger: "@",
selectTemplate: (item: any) => {
- let it: PersonTribute = item.original;
+ const it: PersonTribute = item.original;
return `[${it.key}](${it.view.person.actor_id})`;
},
values: debounce(async (text: string, cb: any) => {
{
trigger: "!",
selectTemplate: (item: any) => {
- let it: CommunityTribute = item.original;
+ const it: CommunityTribute = item.original;
return `[${it.key}](${it.view.community.actor_id})`;
},
values: debounce(async (text: string, cb: any) => {
});
}
+function setupEmojiDataModel(custom_emoji_views: CustomEmojiView[]) {
+ const groupedEmojis = groupBy(
+ custom_emoji_views,
+ x => x.custom_emoji.category
+ );
+ for (const [category, emojis] of Object.entries(groupedEmojis)) {
+ customEmojis.push({
+ id: category,
+ name: category,
+ emojis: emojis.map(emoji => ({
+ id: emoji.custom_emoji.shortcode,
+ name: emoji.custom_emoji.shortcode,
+ keywords: emoji.keywords.map(x => x.keyword),
+ skins: [{ src: emoji.custom_emoji.image_url }],
+ })),
+ });
+ }
+ customEmojisLookup = new Map(
+ custom_emoji_views.map(view => [view.custom_emoji.shortcode, view])
+ );
+}
+
+export function updateEmojiDataModel(custom_emoji_view: CustomEmojiView) {
+ const emoji: EmojiMartCustomEmoji = {
+ id: custom_emoji_view.custom_emoji.shortcode,
+ name: custom_emoji_view.custom_emoji.shortcode,
+ keywords: custom_emoji_view.keywords.map(x => x.keyword),
+ skins: [{ src: custom_emoji_view.custom_emoji.image_url }],
+ };
+ const categoryIndex = customEmojis.findIndex(
+ x => x.id == custom_emoji_view.custom_emoji.category
+ );
+ if (categoryIndex == -1) {
+ customEmojis.push({
+ id: custom_emoji_view.custom_emoji.category,
+ name: custom_emoji_view.custom_emoji.category,
+ emojis: [emoji],
+ });
+ } else {
+ const emojiIndex = customEmojis[categoryIndex].emojis.findIndex(
+ x => x.id == custom_emoji_view.custom_emoji.shortcode
+ );
+ if (emojiIndex == -1) {
+ customEmojis[categoryIndex].emojis.push(emoji);
+ } else {
+ customEmojis[categoryIndex].emojis[emojiIndex] = emoji;
+ }
+ }
+ customEmojisLookup.set(
+ custom_emoji_view.custom_emoji.shortcode,
+ custom_emoji_view
+ );
+}
+
+export function removeFromEmojiDataModel(id: number) {
+ let view: CustomEmojiView | undefined;
+ for (const item of customEmojisLookup.values()) {
+ if (item.custom_emoji.id === id) {
+ view = item;
+ break;
+ }
+ }
+ if (!view) return;
+ const categoryIndex = customEmojis.findIndex(
+ x => x.id == view?.custom_emoji.category
+ );
+ const emojiIndex = customEmojis[categoryIndex].emojis.findIndex(
+ x => x.id == view?.custom_emoji.shortcode
+ );
+ customEmojis[categoryIndex].emojis = customEmojis[
+ categoryIndex
+ ].emojis.splice(emojiIndex, 1);
+
+ customEmojisLookup.delete(view?.custom_emoji.shortcode);
+}
+
+function setupMarkdown() {
+ const markdownItConfig: MarkdownIt.Options = {
+ html: false,
+ linkify: true,
+ typographer: true,
+ };
+
+ const emojiDefs = Array.from(customEmojisLookup.entries()).reduce(
+ (main, [key, value]) => ({ ...main, [key]: value }),
+ {}
+ );
+ md = new MarkdownIt(markdownItConfig)
+ .use(markdown_it_sub)
+ .use(markdown_it_sup)
+ .use(markdown_it_footnote)
+ .use(markdown_it_html5_embed, html5EmbedConfig)
+ .use(markdown_it_container, "spoiler", spoilerConfig)
+ .use(markdown_it_emoji, {
+ defs: emojiDefs,
+ });
+
+ mdNoImages = new MarkdownIt(markdownItConfig)
+ .use(markdown_it_sub)
+ .use(markdown_it_sup)
+ .use(markdown_it_footnote)
+ .use(markdown_it_html5_embed, html5EmbedConfig)
+ .use(markdown_it_container, "spoiler", spoilerConfig)
+ .use(markdown_it_emoji, {
+ defs: emojiDefs,
+ })
+ .disable("image");
+ var defaultRenderer = md.renderer.rules.image;
+ md.renderer.rules.image = function (
+ tokens: Token[],
+ idx: number,
+ options: MarkdownIt.Options,
+ env: any,
+ self: Renderer
+ ) {
+ //Provide custom renderer for our emojis to allow us to add a css class and force size dimensions on them.
+ const item = tokens[idx] as any;
+ const title = item.attrs.length >= 3 ? item.attrs[2][1] : "";
+ const src: string = item.attrs[0][1];
+ const isCustomEmoji = customEmojisLookup.get(title) != undefined;
+ if (!isCustomEmoji) {
+ return defaultRenderer?.(tokens, idx, options, env, self) ?? "";
+ }
+ const alt_text = item.content;
+ return `<img class="icon icon-emoji" src="${src}" title="${title}" alt="${alt_text}"/>`;
+ };
+}
+
+export function getEmojiMart(
+ onEmojiSelect: (e: any) => void,
+ customPickerOptions: any = {}
+) {
+ const pickerOptions = {
+ ...customPickerOptions,
+ onEmojiSelect: onEmojiSelect,
+ custom: customEmojis,
+ };
+ return new Picker(pickerOptions);
+}
+
var tippyInstance: any;
if (isBrowser()) {
tippyInstance = tippy("[data-tippy-content]");
interface PersonTribute {
key: string;
- view: PersonViewSafe;
+ view: PersonView;
}
async function personSearch(text: string): Promise<PersonTribute[]> {
- let users = (await fetchUsers(text)).users;
- let persons: PersonTribute[] = users.map(pv => {
- let tribute: PersonTribute = {
- key: `@${pv.person.name}@${hostname(pv.person.actor_id)}`,
- view: pv,
- };
- return tribute;
- });
- return persons;
+ const usersResponse = await fetchUsers(text);
+
+ return usersResponse.map(pv => ({
+ key: `@${pv.person.name}@${hostname(pv.person.actor_id)}`,
+ view: pv,
+ }));
}
interface CommunityTribute {
}
async function communitySearch(text: string): Promise<CommunityTribute[]> {
- let comms = (await fetchCommunities(text)).communities;
- let communities: CommunityTribute[] = comms.map(cv => {
- let tribute: CommunityTribute = {
- key: `!${cv.community.name}@${hostname(cv.community.actor_id)}`,
- view: cv,
- };
- return tribute;
- });
- return communities;
-}
-
-export function getListingTypeFromProps(props: any): ListingType {
- return props.match.params.listing_type
- ? routeListingTypeToEnum(props.match.params.listing_type)
- : UserService.Instance.myUserInfo
- ? Object.values(ListingType)[
- UserService.Instance.myUserInfo.local_user_view.local_user
- .default_listing_type
- ]
- : ListingType.Local;
-}
-
-export function getListingTypeFromPropsNoDefault(props: any): ListingType {
- return props.match.params.listing_type
- ? routeListingTypeToEnum(props.match.params.listing_type)
- : ListingType.Local;
-}
-
-// TODO might need to add a user setting for this too
-export function getDataTypeFromProps(props: any): DataType {
- return props.match.params.data_type
- ? routeDataTypeToEnum(props.match.params.data_type)
- : DataType.Post;
-}
-
-export function getSortTypeFromProps(props: any): SortType {
- return props.match.params.sort
- ? routeSortTypeToEnum(props.match.params.sort)
- : UserService.Instance.myUserInfo
- ? Object.values(SortType)[
- UserService.Instance.myUserInfo.local_user_view.local_user
- .default_sort_type
- ]
- : SortType.Active;
-}
+ const communitiesResponse = await fetchCommunities(text);
-export function getPageFromProps(props: any): number {
- return props.match.params.page ? Number(props.match.params.page) : 1;
+ return communitiesResponse.map(cv => ({
+ key: `!${cv.community.name}@${hostname(cv.community.actor_id)}`,
+ view: cv,
+ }));
}
export function getRecipientIdFromProps(props: any): number {
: 1;
}
-export function getIdFromProps(props: any): number {
- return Number(props.match.params.id);
+export function getIdFromProps(props: any): number | undefined {
+ const id = props.match.params.post_id;
+ return id ? Number(id) : undefined;
}
-export function getCommentIdFromProps(props: any): number {
- return Number(props.match.params.comment_id);
+export function getCommentIdFromProps(props: any): number | undefined {
+ const id = props.match.params.comment_id;
+ return id ? Number(id) : undefined;
}
-export function getUsernameFromProps(props: any): string {
- return props.match.params.username;
-}
-
-export function editCommentRes(data: CommentView, comments: CommentView[]) {
- let found = comments.find(c => c.comment.id == data.comment.id);
- if (found) {
- found.comment.content = data.comment.content;
- found.comment.updated = data.comment.updated;
- found.comment.removed = data.comment.removed;
- found.comment.deleted = data.comment.deleted;
- found.counts.upvotes = data.counts.upvotes;
- found.counts.downvotes = data.counts.downvotes;
- found.counts.score = data.counts.score;
- }
-}
+type ImmutableListKey =
+ | "comment"
+ | "comment_reply"
+ | "person_mention"
+ | "community"
+ | "private_message"
+ | "post"
+ | "post_report"
+ | "comment_report"
+ | "private_message_report"
+ | "registration_application";
-export function saveCommentRes(data: CommentView, comments: CommentView[]) {
- let found = comments.find(c => c.comment.id == data.comment.id);
- if (found) {
- found.saved = data.saved;
- }
+function editListImmutable<
+ T extends { [key in F]: { id: number } },
+ F extends ImmutableListKey
+>(fieldName: F, data: T, list: T[]): T[] {
+ return [
+ ...list.map(c => (c[fieldName].id === data[fieldName].id ? data : c)),
+ ];
}
-export function updatePersonBlock(
- data: BlockPersonResponse
-): PersonBlockView[] {
- if (data.blocked) {
- UserService.Instance.myUserInfo.person_blocks.push({
- person: UserService.Instance.myUserInfo.local_user_view.person,
- target: data.person_view.person,
- });
- toast(`${i18n.t("blocked")} ${data.person_view.person.name}`);
- } else {
- UserService.Instance.myUserInfo.person_blocks =
- UserService.Instance.myUserInfo.person_blocks.filter(
- i => i.target.id != data.person_view.person.id
- );
- toast(`${i18n.t("unblocked")} ${data.person_view.person.name}`);
- }
- return UserService.Instance.myUserInfo.person_blocks;
+export function editComment(
+ data: CommentView,
+ comments: CommentView[]
+): CommentView[] {
+ return editListImmutable("comment", data, comments);
}
-export function updateCommunityBlock(
- data: BlockCommunityResponse
-): CommunityBlockView[] {
- if (data.blocked) {
- UserService.Instance.myUserInfo.community_blocks.push({
- person: UserService.Instance.myUserInfo.local_user_view.person,
- community: data.community_view.community,
- });
- toast(`${i18n.t("blocked")} ${data.community_view.community.name}`);
- } else {
- UserService.Instance.myUserInfo.community_blocks =
- UserService.Instance.myUserInfo.community_blocks.filter(
- i => i.community.id != data.community_view.community.id
- );
- toast(`${i18n.t("unblocked")} ${data.community_view.community.name}`);
- }
- return UserService.Instance.myUserInfo.community_blocks;
+export function editCommentReply(
+ data: CommentReplyView,
+ replies: CommentReplyView[]
+): CommentReplyView[] {
+ return editListImmutable("comment_reply", data, replies);
}
-export function createCommentLikeRes(
- data: CommentView,
- comments: CommentView[]
-) {
- let found = comments.find(c => c.comment.id === data.comment.id);
- if (found) {
- found.counts.score = data.counts.score;
- found.counts.upvotes = data.counts.upvotes;
- found.counts.downvotes = data.counts.downvotes;
- if (data.my_vote !== null) {
- found.my_vote = data.my_vote;
- }
- }
+interface WithComment {
+ comment: CommentI;
+ counts: CommentAggregates;
+ my_vote?: number;
+ saved: boolean;
}
-export function createPostLikeFindRes(data: PostView, posts: PostView[]) {
- let found = posts.find(p => p.post.id == data.post.id);
- if (found) {
- createPostLikeRes(data, found);
- }
+export function editMention(
+ data: PersonMentionView,
+ comments: PersonMentionView[]
+): PersonMentionView[] {
+ return editListImmutable("person_mention", data, comments);
}
-export function createPostLikeRes(data: PostView, post_view: PostView) {
- if (post_view) {
- post_view.counts.score = data.counts.score;
- post_view.counts.upvotes = data.counts.upvotes;
- post_view.counts.downvotes = data.counts.downvotes;
- if (data.my_vote !== null) {
- post_view.my_vote = data.my_vote;
- }
- }
+export function editCommunity(
+ data: CommunityView,
+ communities: CommunityView[]
+): CommunityView[] {
+ return editListImmutable("community", data, communities);
}
-export function editPostFindRes(data: PostView, posts: PostView[]) {
- let found = posts.find(p => p.post.id == data.post.id);
- if (found) {
- editPostRes(data, found);
- }
+export function editPrivateMessage(
+ data: PrivateMessageView,
+ messages: PrivateMessageView[]
+): PrivateMessageView[] {
+ return editListImmutable("private_message", data, messages);
}
-export function editPostRes(data: PostView, post: PostView) {
- if (post) {
- post.post.url = data.post.url;
- post.post.name = data.post.name;
- post.post.nsfw = data.post.nsfw;
- post.post.deleted = data.post.deleted;
- post.post.removed = data.post.removed;
- post.post.stickied = data.post.stickied;
- post.post.body = data.post.body;
- post.post.locked = data.post.locked;
- post.saved = data.saved;
- }
+export function editPost(data: PostView, posts: PostView[]): PostView[] {
+ return editListImmutable("post", data, posts);
}
-export function updatePostReportRes(
+export function editPostReport(
data: PostReportView,
reports: PostReportView[]
) {
- let found = reports.find(p => p.post_report.id == data.post_report.id);
- if (found) {
- found.post_report = data.post_report;
- }
+ return editListImmutable("post_report", data, reports);
}
-export function updateCommentReportRes(
+export function editCommentReport(
data: CommentReportView,
reports: CommentReportView[]
-) {
- let found = reports.find(c => c.comment_report.id == data.comment_report.id);
- if (found) {
- found.comment_report = data.comment_report;
- }
+): CommentReportView[] {
+ return editListImmutable("comment_report", data, reports);
}
-export function updateRegistrationApplicationRes(
+export function editPrivateMessageReport(
+ data: PrivateMessageReportView,
+ reports: PrivateMessageReportView[]
+): PrivateMessageReportView[] {
+ return editListImmutable("private_message_report", data, reports);
+}
+
+export function editRegistrationApplication(
data: RegistrationApplicationView,
- applications: RegistrationApplicationView[]
-) {
- let found = applications.find(
- ra => ra.registration_application.id == data.registration_application.id
- );
- if (found) {
- found.registration_application = data.registration_application;
- found.admin = data.admin;
- found.creator_local_user = data.creator_local_user;
- }
+ apps: RegistrationApplicationView[]
+): RegistrationApplicationView[] {
+ return editListImmutable("registration_application", data, apps);
}
-export function commentsToFlatNodes(comments: CommentView[]): CommentNodeI[] {
- let nodes: CommentNodeI[] = [];
- for (let comment of comments) {
- nodes.push({ comment_view: comment });
- }
- return nodes;
+export function editWith<D extends WithComment, L extends WithComment>(
+ { comment, counts, saved, my_vote }: D,
+ list: L[]
+) {
+ return [
+ ...list.map(c =>
+ c.comment.id === comment.id
+ ? { ...c, comment, counts, saved, my_vote }
+ : c
+ ),
+ ];
}
-function commentSort(tree: CommentNodeI[], sort: CommentSortType) {
- // First, put removed and deleted comments at the bottom, then do your other sorts
- if (sort == CommentSortType.Top) {
- tree.sort(
- (a, b) =>
- +a.comment_view.comment.removed - +b.comment_view.comment.removed ||
- +a.comment_view.comment.deleted - +b.comment_view.comment.deleted ||
- b.comment_view.counts.score - a.comment_view.counts.score
- );
- } else if (sort == CommentSortType.New) {
- tree.sort(
- (a, b) =>
- +a.comment_view.comment.removed - +b.comment_view.comment.removed ||
- +a.comment_view.comment.deleted - +b.comment_view.comment.deleted ||
- b.comment_view.comment.published.localeCompare(
- a.comment_view.comment.published
- )
- );
- } else if (sort == CommentSortType.Old) {
- tree.sort(
- (a, b) =>
- +a.comment_view.comment.removed - +b.comment_view.comment.removed ||
- +a.comment_view.comment.deleted - +b.comment_view.comment.deleted ||
- a.comment_view.comment.published.localeCompare(
- b.comment_view.comment.published
- )
- );
- } else if (sort == CommentSortType.Hot) {
- tree.sort(
- (a, b) =>
- +a.comment_view.comment.removed - +b.comment_view.comment.removed ||
- +a.comment_view.comment.deleted - +b.comment_view.comment.deleted ||
- hotRankComment(b.comment_view) - hotRankComment(a.comment_view)
- );
+export function updatePersonBlock(
+ data: BlockPersonResponse,
+ myUserInfo: MyUserInfo | undefined = UserService.Instance.myUserInfo
+) {
+ if (myUserInfo) {
+ if (data.blocked) {
+ myUserInfo.person_blocks.push({
+ person: myUserInfo.local_user_view.person,
+ target: data.person_view.person,
+ });
+ toast(`${i18n.t("blocked")} ${data.person_view.person.name}`);
+ } else {
+ myUserInfo.person_blocks = myUserInfo.person_blocks.filter(
+ i => i.target.id !== data.person_view.person.id
+ );
+ toast(`${i18n.t("unblocked")} ${data.person_view.person.name}`);
+ }
}
+}
- // Go through the children recursively
- for (let node of tree) {
- if (node.children) {
- commentSort(node.children, sort);
+export function updateCommunityBlock(
+ data: BlockCommunityResponse,
+ myUserInfo: MyUserInfo | undefined = UserService.Instance.myUserInfo
+) {
+ if (myUserInfo) {
+ if (data.blocked) {
+ myUserInfo.community_blocks.push({
+ person: myUserInfo.local_user_view.person,
+ community: data.community_view.community,
+ });
+ toast(`${i18n.t("blocked")} ${data.community_view.community.name}`);
+ } else {
+ myUserInfo.community_blocks = myUserInfo.community_blocks.filter(
+ i => i.community.id !== data.community_view.community.id
+ );
+ toast(`${i18n.t("unblocked")} ${data.community_view.community.name}`);
}
}
}
-export function commentSortSortType(tree: CommentNodeI[], sort: SortType) {
- commentSort(tree, convertCommentSortType(sort));
+export function commentsToFlatNodes(comments: CommentView[]): CommentNodeI[] {
+ const nodes: CommentNodeI[] = [];
+ for (const comment of comments) {
+ nodes.push({ comment_view: comment, children: [], depth: 0 });
+ }
+ return nodes;
}
-function convertCommentSortType(sort: SortType): CommentSortType {
+export function convertCommentSortType(sort: SortType): CommentSortType {
if (
- sort == SortType.TopAll ||
- sort == SortType.TopDay ||
- sort == SortType.TopWeek ||
- sort == SortType.TopMonth ||
- sort == SortType.TopYear
+ sort == "TopAll" ||
+ sort == "TopDay" ||
+ sort == "TopWeek" ||
+ sort == "TopMonth" ||
+ sort == "TopYear"
) {
- return CommentSortType.Top;
- } else if (sort == SortType.New) {
- return CommentSortType.New;
- } else if (sort == SortType.Hot || sort == SortType.Active) {
- return CommentSortType.Hot;
+ return "Top";
+ } else if (sort == "New") {
+ return "New";
+ } else if (sort == "Hot" || sort == "Active") {
+ return "Hot";
} else {
- return CommentSortType.Hot;
+ return "Hot";
}
}
export function buildCommentsTree(
comments: CommentView[],
- commentSortType: CommentSortType
+ parentComment: boolean
): CommentNodeI[] {
- let map = new Map<number, CommentNodeI>();
- for (let comment_view of comments) {
- let node: CommentNodeI = {
- comment_view: comment_view,
+ const map = new Map<number, CommentNodeI>();
+ const depthOffset = !parentComment
+ ? 0
+ : getDepthFromComment(comments[0].comment) ?? 0;
+
+ for (const comment_view of comments) {
+ const depthI = getDepthFromComment(comment_view.comment) ?? 0;
+ const depth = depthI ? depthI - depthOffset : 0;
+ const node: CommentNodeI = {
+ comment_view,
children: [],
+ depth,
};
map.set(comment_view.comment.id, { ...node });
}
- let tree: CommentNodeI[] = [];
- for (let comment_view of comments) {
- let child = map.get(comment_view.comment.id);
- let parent_id = comment_view.comment.parent_id;
- if (parent_id) {
- let parent = map.get(parent_id);
- // Necessary because blocked comment might not exist
- if (parent) {
- parent.children.push(child);
- }
- } else {
- tree.push(child);
- }
- setDepth(child);
+ const tree: CommentNodeI[] = [];
+
+ // if its a parent comment fetch, then push the first comment to the top node.
+ if (parentComment) {
+ const cNode = map.get(comments[0].comment.id);
+ if (cNode) {
+ tree.push(cNode);
+ }
}
- commentSort(tree, commentSortType);
+ for (const comment_view of comments) {
+ const child = map.get(comment_view.comment.id);
+ if (child) {
+ const parent_id = getCommentParentId(comment_view.comment);
+ if (parent_id) {
+ const parent = map.get(parent_id);
+ // Necessary because blocked comment might not exist
+ if (parent) {
+ parent.children.push(child);
+ }
+ } else {
+ if (!parentComment) {
+ tree.push(child);
+ }
+ }
+ }
+ }
return tree;
}
-function setDepth(node: CommentNodeI, i = 0) {
- for (let child of node.children) {
- child.depth = i;
- setDepth(child, i + 1);
- }
+export function getCommentParentId(comment?: CommentI): number | undefined {
+ const split = comment?.path.split(".");
+ // remove the 0
+ split?.shift();
+
+ return split && split.length > 1
+ ? Number(split.at(split.length - 2))
+ : undefined;
}
-export function insertCommentIntoTree(tree: CommentNodeI[], cv: CommentView) {
+export function getDepthFromComment(comment?: CommentI): number | undefined {
+ const len = comment?.path.split(".").length;
+ return len ? len - 2 : undefined;
+}
+
+// TODO make immutable
+export function insertCommentIntoTree(
+ tree: CommentNodeI[],
+ cv: CommentView,
+ parentComment: boolean
+) {
// Building a fake node to be used for later
- let node: CommentNodeI = {
+ const node: CommentNodeI = {
comment_view: cv,
children: [],
depth: 0,
};
- if (cv.comment.parent_id) {
- let parentComment = searchCommentTree(tree, cv.comment.parent_id);
- if (parentComment) {
- node.depth = parentComment.depth + 1;
- parentComment.children.unshift(node);
+ const parentId = getCommentParentId(cv.comment);
+ if (parentId) {
+ const parent_comment = searchCommentTree(tree, parentId);
+ if (parent_comment) {
+ node.depth = parent_comment.depth + 1;
+ parent_comment.children.unshift(node);
}
- } else {
+ } else if (!parentComment) {
tree.unshift(node);
}
}
export function searchCommentTree(
tree: CommentNodeI[],
id: number
-): CommentNodeI {
- for (let node of tree) {
+): CommentNodeI | undefined {
+ for (const node of tree) {
if (node.comment_view.comment.id === id) {
return node;
}
}
}
}
- return null;
+ return undefined;
}
export const colorList: string[] = [
hsl(0),
+ hsl(50),
hsl(100),
hsl(150),
hsl(200),
return `hsla(${num}, 35%, 50%, 1)`;
}
-export function previewLines(
- text: string,
- maxChars = 300,
- maxLines = 1
-): string {
- return (
- text
- .slice(0, maxChars)
- .split("\n")
- // Use lines * 2 because markdown requires 2 lines
- .slice(0, maxLines * 2)
- .join("\n") + "..."
- );
-}
-
export function hostname(url: string): string {
- let cUrl = new URL(url);
+ const cUrl = new URL(url);
return cUrl.port ? `${cUrl.hostname}:${cUrl.port}` : `${cUrl.hostname}`;
}
export function validTitle(title?: string): boolean {
// Initial title is null, minimum length is taken care of by textarea's minLength={3}
- if (title === null || title.length < 3) return true;
+ if (!title || title.length < 3) return true;
const regex = new RegExp(/.*\S.*/, "g");
return typeof window !== "undefined";
}
-export function setIsoData(context: any): IsoData {
- let isoData: IsoData = isBrowser()
- ? window.isoData
- : context.router.staticContext;
- return isoData;
-}
-
-export function wsSubscribe(parseMessage: any): Subscription {
+export function setIsoData<T extends Record<string, RequestState<any>>>(
+ context: any
+): IsoData<T> {
+ // If its the browser, you need to deserialize the data from the window
if (isBrowser()) {
- return WebSocketService.Instance.subject
- .pipe(retryWhen(errors => errors.pipe(delay(3000), take(10))))
- .subscribe(
- msg => parseMessage(msg),
- err => console.error(err),
- () => console.log("complete")
- );
- } else {
- return null;
- }
-}
-
-export function setOptionalAuth(obj: any, auth = UserService.Instance.auth) {
- if (auth) {
- obj.auth = auth;
- }
-}
-
-export function authField(
- throwErr = true,
- auth = UserService.Instance.auth
-): string {
- if (auth == null && throwErr) {
- toast(i18n.t("not_logged_in"), "danger");
- throw "Not logged in";
- } else {
- return auth;
- }
+ return window.isoData;
+ } else return context.router.staticContext;
}
moment.updateLocale("en", {
});
export function saveScrollPosition(context: any) {
- let path: string = context.router.route.location.pathname;
- let y = window.scrollY;
+ const path: string = context.router.route.location.pathname;
+ const y = window.scrollY;
sessionStorage.setItem(`scrollPosition_${path}`, y.toString());
}
export function restoreScrollPosition(context: any) {
- let path: string = context.router.route.location.pathname;
- let y = Number(sessionStorage.getItem(`scrollPosition_${path}`));
+ const path: string = context.router.route.location.pathname;
+ const y = Number(sessionStorage.getItem(`scrollPosition_${path}`));
window.scrollTo(0, y);
}
export function showLocal(isoData: IsoData): boolean {
- return isoData.site_res.federated_instances?.linked.length > 0;
+ return isoData.site_res.site_view.local_site.federation_enabled;
}
-interface ChoicesValue {
+export interface Choice {
value: string;
label: string;
+ disabled?: boolean;
}
-export function communityToChoice(cv: CommunityView): ChoicesValue {
- let choice: ChoicesValue = {
+export function getUpdatedSearchId(id?: number | null, urlId?: number | null) {
+ return id === null
+ ? undefined
+ : ((id ?? urlId) === 0 ? undefined : id ?? urlId)?.toString();
+}
+
+export function communityToChoice(cv: CommunityView): Choice {
+ return {
value: cv.community.id.toString(),
label: communitySelectName(cv),
};
- return choice;
}
-export function personToChoice(pvs: PersonViewSafe): ChoicesValue {
- let choice: ChoicesValue = {
+export function personToChoice(pvs: PersonView): Choice {
+ return {
value: pvs.person.id.toString(),
label: personSelectName(pvs),
};
- return choice;
}
-export async function fetchCommunities(q: string) {
- let form: Search = {
+function fetchSearchResults(q: string, type_: SearchType) {
+ const form: Search = {
q,
- type_: SearchType.Communities,
- sort: SortType.TopAll,
- listing_type: ListingType.All,
+ type_,
+ sort: "TopAll",
+ listing_type: "All",
page: 1,
limit: fetchLimit,
- auth: authField(false),
+ auth: myAuth(),
};
- let client = new LemmyHttp(httpBase);
- return client.search(form);
+
+ return HttpService.client.search(form);
+}
+
+export async function fetchCommunities(q: string) {
+ const res = await fetchSearchResults(q, "Communities");
+
+ return res.state === "success" ? res.data.communities : [];
}
export async function fetchUsers(q: string) {
- let form: Search = {
- q,
- type_: SearchType.Users,
- sort: SortType.TopAll,
- listing_type: ListingType.All,
- page: 1,
- limit: fetchLimit,
- auth: authField(false),
- };
- let client = new LemmyHttp(httpBase);
- return client.search(form);
-}
-
-export const choicesConfig = {
- shouldSort: false,
- searchResultLimit: fetchLimit,
- classNames: {
- containerOuter: "choices",
- containerInner: "choices__inner bg-secondary border-0",
- input: "form-control",
- inputCloned: "choices__input--cloned",
- list: "choices__list",
- listItems: "choices__list--multiple",
- listSingle: "choices__list--single",
- listDropdown: "choices__list--dropdown",
- item: "choices__item bg-secondary",
- itemSelectable: "choices__item--selectable",
- itemDisabled: "choices__item--disabled",
- itemChoice: "choices__item--choice",
- placeholder: "choices__placeholder",
- group: "choices__group",
- groupHeading: "choices__heading",
- button: "choices__button",
- activeState: "is-active",
- focusState: "is-focused",
- openState: "is-open",
- disabledState: "is-disabled",
- highlightedState: "text-info",
- selectedState: "text-info",
- flippedState: "is-flipped",
- loadingState: "is-loading",
- noResults: "has-no-results",
- noChoices: "has-no-choices",
- },
-};
+ const res = await fetchSearchResults(q, "Users");
+
+ return res.state === "success" ? res.data.users : [];
+}
export function communitySelectName(cv: CommunityView): string {
return cv.community.local
: `${hostname(cv.community.actor_id)}/${cv.community.title}`;
}
-export function personSelectName(pvs: PersonViewSafe): string {
- let pName = pvs.person.display_name || pvs.person.name;
- return pvs.person.local ? pName : `${hostname(pvs.person.actor_id)}/${pName}`;
+export function personSelectName({
+ person: { display_name, name, local, actor_id },
+}: PersonView): string {
+ const pName = display_name ?? name;
+ return local ? pName : `${hostname(actor_id)}/${pName}`;
}
-export function initializeSite(site: GetSiteResponse) {
- UserService.Instance.myUserInfo = site.my_user;
+export function initializeSite(site?: GetSiteResponse) {
+ UserService.Instance.myUserInfo = site?.my_user;
i18n.changeLanguage(getLanguages()[0]);
+ if (site) {
+ setupEmojiDataModel(site.custom_emojis ?? []);
+ }
+ setupMarkdown();
}
const SHORTNUM_SI_FORMAT = new Intl.NumberFormat("en-US", {
return SHORTNUM_SI_FORMAT.format(value);
}
-export function isBanned(ps: PersonSafe): boolean {
+export function isBanned(ps: Person): boolean {
+ const expires = ps.ban_expires;
// Add Z to convert from UTC date
- if (ps.ban_expires) {
- if (ps.banned && new Date(ps.ban_expires + "Z") > new Date()) {
+ // TODO this check probably isn't necessary anymore
+ if (expires) {
+ if (ps.banned && new Date(expires + "Z") > new Date()) {
return true;
} else {
return false;
}
}
-export function pushNotNull(array: any[], new_item?: any) {
- if (new_item) {
- array.push(...new_item);
+export function myAuth(): string | undefined {
+ return UserService.Instance.auth();
+}
+
+export function myAuthRequired(): string {
+ return UserService.Instance.auth(true) ?? "";
+}
+
+export function enableDownvotes(siteRes: GetSiteResponse): boolean {
+ return siteRes.site_view.local_site.enable_downvotes;
+}
+
+export function enableNsfw(siteRes: GetSiteResponse): boolean {
+ return siteRes.site_view.local_site.enable_nsfw;
+}
+
+export function postToCommentSortType(sort: SortType): CommentSortType {
+ switch (sort) {
+ case "Active":
+ case "Hot":
+ return "Hot";
+ case "New":
+ case "NewComments":
+ return "New";
+ case "Old":
+ return "Old";
+ default:
+ return "Top";
+ }
+}
+
+export function canCreateCommunity(
+ siteRes: GetSiteResponse,
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ const adminOnly = siteRes.site_view.local_site.community_creation_admin_only;
+ // TODO: Make this check if user is logged on as well
+ return !adminOnly || amAdmin(myUserInfo);
+}
+
+export function isPostBlocked(
+ pv: PostView,
+ myUserInfo: MyUserInfo | undefined = UserService.Instance.myUserInfo
+): boolean {
+ return (
+ (myUserInfo?.community_blocks
+ .map(c => c.community.id)
+ .includes(pv.community.id) ||
+ myUserInfo?.person_blocks
+ .map(p => p.target.id)
+ .includes(pv.creator.id)) ??
+ false
+ );
+}
+
+/// Checks to make sure you can view NSFW posts. Returns true if you can.
+export function nsfwCheck(
+ pv: PostView,
+ myUserInfo = UserService.Instance.myUserInfo
+): boolean {
+ const nsfw = pv.post.nsfw || pv.community.nsfw;
+ const myShowNsfw = myUserInfo?.local_user_view.local_user.show_nsfw ?? false;
+ return !nsfw || (nsfw && myShowNsfw);
+}
+
+export function getRandomFromList<T>(list: T[]): T | undefined {
+ return list.length == 0
+ ? undefined
+ : list.at(Math.floor(Math.random() * list.length));
+}
+
+/**
+ * This shows what language you can select
+ *
+ * Use showAll for the site form
+ * Use showSite for the profile and community forms
+ * Use false for both those to filter on your profile and site ones
+ */
+export function selectableLanguages(
+ allLanguages: Language[],
+ siteLanguages: number[],
+ showAll?: boolean,
+ showSite?: boolean,
+ myUserInfo = UserService.Instance.myUserInfo
+): Language[] {
+ const allLangIds = allLanguages.map(l => l.id);
+ let myLangs = myUserInfo?.discussion_languages ?? allLangIds;
+ myLangs = myLangs.length == 0 ? allLangIds : myLangs;
+ const siteLangs = siteLanguages.length == 0 ? allLangIds : siteLanguages;
+
+ if (showAll) {
+ return allLanguages;
+ } else {
+ if (showSite) {
+ return allLanguages.filter(x => siteLangs.includes(x.id));
+ } else {
+ return allLanguages
+ .filter(x => siteLangs.includes(x.id))
+ .filter(x => myLangs.includes(x.id));
+ }
+ }
+}
+
+interface EmojiMartCategory {
+ id: string;
+ name: string;
+ emojis: EmojiMartCustomEmoji[];
+}
+
+interface EmojiMartCustomEmoji {
+ id: string;
+ name: string;
+ keywords: string[];
+ skins: EmojiMartSkin[];
+}
+
+interface EmojiMartSkin {
+ src: string;
+}
+
+const groupBy = <T>(
+ array: T[],
+ predicate: (value: T, index: number, array: T[]) => string
+) =>
+ array.reduce((acc, value, index, array) => {
+ (acc[predicate(value, index, array)] ||= []).push(value);
+ return acc;
+ }, {} as { [key: string]: T[] });
+
+export type QueryParams<T extends Record<string, any>> = {
+ [key in keyof T]?: string;
+};
+
+export function getQueryParams<T extends Record<string, any>>(processors: {
+ [K in keyof T]: (param: string) => T[K];
+}): T {
+ if (isBrowser()) {
+ const searchParams = new URLSearchParams(window.location.search);
+
+ return Array.from(Object.entries(processors)).reduce(
+ (acc, [key, process]) => ({
+ ...acc,
+ [key]: process(searchParams.get(key)),
+ }),
+ {} as T
+ );
}
+
+ return {} as T;
+}
+
+export function getQueryString<T extends Record<string, string | undefined>>(
+ obj: T
+) {
+ return Object.entries(obj)
+ .filter(([, val]) => val !== undefined && val !== null)
+ .reduce(
+ (acc, [key, val], index) => `${acc}${index > 0 ? "&" : ""}${key}=${val}`,
+ "?"
+ );
+}
+
+export function isAuthPath(pathname: string) {
+ return /create_.*|inbox|settings|admin|reports|registration_applications/g.test(
+ pathname
+ );
+}
+
+export function canShare() {
+ return isBrowser() && !!navigator.canShare;
}
+
+export function share(shareData: ShareData) {
+ if (isBrowser()) {
+ navigator.share(shareData);
+ }
+}
+
+export function newVote(voteType: VoteType, myVote?: number): number {
+ if (voteType == VoteType.Upvote) {
+ return myVote == 1 ? 0 : 1;
+ } else {
+ return myVote == -1 ? 0 : -1;
+ }
+}
+
+export type RouteDataResponse<T extends Record<string, any>> = {
+ [K in keyof T]: RequestState<Exclude<T[K], undefined>>;
+};