-import { Err, None, Ok, Option, Result, Some } from "@sniptt/monads";
-import { ClassConstructor, deserialize, serialize } from "class-transformer";
+import { Picker } from "emoji-mart";
import emojiShortName from "emoji-short-name";
import {
BlockCommunityResponse,
BlockPersonResponse,
+ CommentAggregates,
Comment as CommentI,
- CommentNode as CommentNodeI,
+ CommentReplyView,
CommentReportView,
CommentSortType,
CommentView,
- CommunityBlockView,
CommunityModeratorView,
CommunityView,
+ CustomEmojiView,
GetSiteMetadata,
GetSiteResponse,
+ Language,
LemmyHttp,
- LemmyWebsocket,
- ListingType,
MyUserInfo,
- PersonBlockView,
- PersonSafe,
- PersonViewSafe,
+ Person,
+ PersonMentionView,
+ PersonView,
PostReportView,
PostView,
PrivateMessageReportView,
SearchType,
SortType,
} 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 { DataType, IsoData } from "./interfaces";
-import { UserService, WebSocketService } from "./services";
+import { CommentNodeI, DataType, IsoData, VoteType } from "./interfaces";
+import { HttpService, UserService } from "./services";
-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 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 const md = new markdown_it({
- html: false,
- 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(
- mods: Option<CommunityModeratorView[]>,
- admins: Option<PersonViewSafe[]>,
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
- .unwrapOr([])
- .map(a => a.person.id)
- .concat(mods.unwrapOr([]).map(m => m.moderator.id));
-
- return myUserInfo.match({
- some: me => {
- let myIndex = adminsThenMods.findIndex(
- id => id == me.local_user_view.person.id
- );
- if (myIndex == -1) {
- return false;
- } else {
- // onSelf +1 on mod actions not for yourself, IE ban, remove, etc
- adminsThenMods = adminsThenMods.slice(0, myIndex + (onSelf ? 0 : 1));
- return !adminsThenMods.includes(creator_id);
- }
- },
- none: false,
- });
+ let adminsThenMods =
+ admins
+ ?.map(a => a.person.id)
+ .concat(mods?.map(m => m.moderator.id) ?? []) ?? [];
+
+ if (myUserInfo) {
+ const myIndex = adminsThenMods.findIndex(
+ id => id == myUserInfo.local_user_view.person.id
+ );
+ if (myIndex == -1) {
+ return false;
+ } else {
+ // onSelf +1 on mod actions not for yourself, IE ban, remove, etc
+ adminsThenMods = adminsThenMods.slice(0, myIndex + (onSelf ? 0 : 1));
+ return !adminsThenMods.includes(creator_id);
+ }
+ } else {
+ return false;
+ }
}
export function canAdmin(
- admins: Option<PersonViewSafe[]>,
- creator_id: number,
+ creatorId: number,
+ admins?: PersonView[],
myUserInfo = UserService.Instance.myUserInfo,
onSelf = false
): boolean {
- return canMod(None, admins, creator_id, myUserInfo, onSelf);
+ return canMod(creatorId, undefined, admins, myUserInfo, onSelf);
}
export function isMod(
- mods: Option<CommunityModeratorView[]>,
- creator_id: number
+ creatorId: number,
+ mods?: CommunityModeratorView[]
): boolean {
- return mods.match({
- some: mods => mods.map(m => m.moderator.id).includes(creator_id),
- none: false,
- });
+ return mods?.map(m => m.moderator.id).includes(creatorId) ?? false;
}
export function amMod(
- mods: Option<CommunityModeratorView[]>,
+ mods?: CommunityModeratorView[],
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- return myUserInfo.match({
- some: mui => isMod(mods, mui.local_user_view.person.id),
- none: false,
- });
+ return myUserInfo ? isMod(myUserInfo.local_user_view.person.id, mods) : false;
}
-export function isAdmin(
- admins: Option<PersonViewSafe[]>,
- creator_id: number
-): boolean {
- return admins.match({
- some: admins => admins.map(a => a.person.id).includes(creator_id),
- none: 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
- .map(mui => mui.local_user_view.person.admin)
- .unwrapOr(false);
+ return myUserInfo?.local_user_view.person.admin ?? false;
}
export function amCommunityCreator(
- mods: Option<CommunityModeratorView[]>,
creator_id: number,
+ mods?: CommunityModeratorView[],
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- return mods.match({
- some: mods =>
- myUserInfo
- .map(mui => mui.local_user_view.person.id)
- .match({
- some: myId =>
- myId == mods[0].moderator.id &&
- // Don't allow mod actions on yourself
- myId != creator_id,
- none: false,
- }),
- none: false,
- });
+ 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(
- admins: Option<PersonViewSafe[]>,
creator_id: number,
+ admins?: PersonView[],
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- return admins.match({
- some: admins =>
- myUserInfo
- .map(mui => mui.local_user_view.person.id)
- .match({
- some: myId =>
- myId == admins[0].person.id &&
- // Don't allow mod actions on yourself
- myId != creator_id,
- none: false,
- }),
- none: false,
- });
+ const myId = myUserInfo?.local_user_view.person.id;
+ return myId == admins?.at(0)?.person.id && myId != creator_id;
}
export function amTopMod(
- mods: Option<CommunityModeratorView[]>,
+ mods: CommunityModeratorView[],
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- return mods.match({
- some: mods =>
- myUserInfo.match({
- some: mui => mods[0].moderator.id == mui.local_user_view.person.id,
- none: false,
- }),
- none: false,
- });
+ 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 = new 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,
myUserInfo = UserService.Instance.myUserInfo
): string[] {
- let myLang = myUserInfo
- .map(m => m.local_user_view.local_user.interface_language)
- .unwrapOr("browser");
- let lang = override || myLang;
+ 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) {
}
export function showAvatars(
- myUserInfo: Option<MyUserInfo> = UserService.Instance.myUserInfo
+ myUserInfo = UserService.Instance.myUserInfo
): boolean {
- return myUserInfo
- .map(m => m.local_user_view.local_user.show_avatars)
- .unwrapOr(true);
+ return myUserInfo?.local_user_view.local_user.show_avatars ?? true;
}
export function showScores(
- myUserInfo: Option<MyUserInfo> = UserService.Instance.myUserInfo
+ myUserInfo = UserService.Instance.myUserInfo
): boolean {
- return myUserInfo
- .map(m => m.local_user_view.local_user.show_scores)
- .unwrapOr(true);
+ return myUserInfo?.local_user_view.local_user.show_scores ?? true;
}
export function isCakeDay(published: string): boolean {
);
}
-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,
- failedDeletePictureText: 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",
}
},
close: true,
- }).showToast();
- }
-}
-
-interface NotifyInfo {
- name: string;
- icon: Option<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,
- 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();
- }
-}
-
-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: `/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);
-
- if (Notification.permission !== "granted") Notification.requestPermission();
- else {
- var notification = new Notification(info.name, {
- ...{ body: info.body },
- ...(info.icon.isSome() && { icon: info.icon.unwrap() }),
});
- notification.onclick = (ev: Event): any => {
- ev.preventDefault();
- router.history.push(info.link);
- };
+ toast.showToast();
}
}
{
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,
- defaultListingType: ListingType,
- myUserInfo = UserService.Instance.myUserInfo
-): ListingType {
- return props.match.params.listing_type
- ? routeListingTypeToEnum(props.match.params.listing_type)
- : myUserInfo.match({
- some: me =>
- Object.values(ListingType)[
- me.local_user_view.local_user.default_listing_type
- ],
- none: defaultListingType,
- });
-}
-
-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,
- myUserInfo = UserService.Instance.myUserInfo
-): SortType {
- return props.match.params.sort
- ? routeSortTypeToEnum(props.match.params.sort)
- : myUserInfo.match({
- some: mui =>
- Object.values(SortType)[
- mui.local_user_view.local_user.default_sort_type
- ],
- none: 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): Option<number> {
- let id: string = props.match.params.post_id;
- return id ? Some(Number(id)) : None;
+export function getIdFromProps(props: any): number | undefined {
+ const id = props.match.params.post_id;
+ return id ? Number(id) : undefined;
}
-export function getCommentIdFromProps(props: any): Option<number> {
- let id: string = props.match.params.comment_id;
- return id ? Some(Number(id)) : None;
+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.distinguished = data.comment.distinguished;
- 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)),
+ ];
}
-// TODO Should only use the return now, no state?
-export function updatePersonBlock(
- data: BlockPersonResponse,
- myUserInfo = UserService.Instance.myUserInfo
-): Option<PersonBlockView[]> {
- return myUserInfo.match({
- some: (mui: MyUserInfo) => {
- if (data.blocked) {
- mui.person_blocks.push({
- person: mui.local_user_view.person,
- target: data.person_view.person,
- });
- toast(`${i18n.t("blocked")} ${data.person_view.person.name}`);
- } else {
- mui.person_blocks = mui.person_blocks.filter(
- i => i.target.id != data.person_view.person.id
- );
- toast(`${i18n.t("unblocked")} ${data.person_view.person.name}`);
- }
- return Some(mui.person_blocks);
- },
- none: None,
- });
+export function editComment(
+ data: CommentView,
+ comments: CommentView[]
+): CommentView[] {
+ return editListImmutable("comment", data, comments);
}
-export function updateCommunityBlock(
- data: BlockCommunityResponse,
- myUserInfo = UserService.Instance.myUserInfo
-): Option<CommunityBlockView[]> {
- return myUserInfo.match({
- some: (mui: MyUserInfo) => {
- if (data.blocked) {
- mui.community_blocks.push({
- person: mui.local_user_view.person,
- community: data.community_view.community,
- });
- toast(`${i18n.t("blocked")} ${data.community_view.community.name}`);
- } else {
- mui.community_blocks = mui.community_blocks.filter(
- i => i.community.id != data.community_view.community.id
- );
- toast(`${i18n.t("unblocked")} ${data.community_view.community.name}`);
- }
- return Some(mui.community_blocks);
- },
- none: None,
- });
+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);
}
-// TODO possible to make these generic?
-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 updatePrivateMessageReportRes(
+export function editPrivateMessageReport(
data: PrivateMessageReportView,
reports: PrivateMessageReportView[]
+): PrivateMessageReportView[] {
+ return editListImmutable("private_message_report", data, reports);
+}
+
+export function editRegistrationApplication(
+ data: RegistrationApplicationView,
+ apps: RegistrationApplicationView[]
+): RegistrationApplicationView[] {
+ return editListImmutable("registration_application", data, apps);
+}
+
+export function editWith<D extends WithComment, L extends WithComment>(
+ { comment, counts, saved, my_vote }: D,
+ list: L[]
) {
- let found = reports.find(
- c => c.private_message_report.id == data.private_message_report.id
- );
- if (found) {
- found.private_message_report = data.private_message_report;
+ return [
+ ...list.map(c =>
+ c.comment.id === comment.id
+ ? { ...c, comment, counts, saved, my_vote }
+ : c
+ ),
+ ];
+}
+
+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}`);
+ }
}
}
-export function updateRegistrationApplicationRes(
- data: RegistrationApplicationView,
- applications: RegistrationApplicationView[]
+export function updateCommunityBlock(
+ data: BlockCommunityResponse,
+ myUserInfo: MyUserInfo | undefined = UserService.Instance.myUserInfo
) {
- 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;
+ 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 commentsToFlatNodes(comments: CommentView[]): CommentNodeI[] {
- let nodes: CommentNodeI[] = [];
- for (let comment of comments) {
+ const nodes: CommentNodeI[] = [];
+ for (const comment of comments) {
nodes.push({ comment_view: comment, children: [], depth: 0 });
}
return nodes;
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";
}
}
comments: CommentView[],
parentComment: boolean
): CommentNodeI[] {
- let map = new Map<number, CommentNodeI>();
- let depthOffset = !parentComment
+ const map = new Map<number, CommentNodeI>();
+ const depthOffset = !parentComment
? 0
- : getDepthFromComment(comments[0].comment);
+ : getDepthFromComment(comments[0].comment) ?? 0;
- for (let comment_view of comments) {
- let node: CommentNodeI = {
- comment_view: comment_view,
+ 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: getDepthFromComment(comment_view.comment) - depthOffset,
+ depth,
};
map.set(comment_view.comment.id, { ...node });
}
- let tree: CommentNodeI[] = [];
+ const tree: CommentNodeI[] = [];
// if its a parent comment fetch, then push the first comment to the top node.
if (parentComment) {
- tree.push(map.get(comments[0].comment.id));
+ const cNode = map.get(comments[0].comment.id);
+ if (cNode) {
+ tree.push(cNode);
+ }
}
- for (let comment_view of comments) {
- let child = map.get(comment_view.comment.id);
- let parent_id = getCommentParentId(comment_view.comment);
- parent_id.match({
- some: parentId => {
- let parent = map.get(parentId);
+ 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);
}
- },
- none: () => {
+ } else {
if (!parentComment) {
tree.push(child);
}
- },
- });
+ }
+ }
}
return tree;
}
-export function getCommentParentId(comment: CommentI): Option<number> {
- let split = comment.path.split(".");
+export function getCommentParentId(comment?: CommentI): number | undefined {
+ const split = comment?.path.split(".");
// remove the 0
- split.shift();
+ split?.shift();
- if (split.length > 1) {
- return Some(Number(split[split.length - 2]));
- } else {
- return None;
- }
+ return split && split.length > 1
+ ? Number(split.at(split.length - 2))
+ : undefined;
}
-export function getDepthFromComment(comment: CommentI): number {
- return comment.path.split(".").length - 2;
+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,
};
- getCommentParentId(cv.comment).match({
- some: parentId => {
- let parentComment = searchCommentTree(tree, parentId);
- parentComment.match({
- some: pComment => {
- node.depth = pComment.depth + 1;
- pComment.children.unshift(node);
- },
- none: void 0,
- });
- },
- none: () => {
- if (!parentComment) {
- tree.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 if (!parentComment) {
+ tree.unshift(node);
+ }
}
export function searchCommentTree(
tree: CommentNodeI[],
id: number
-): Option<CommentNodeI> {
- for (let node of tree) {
+): CommentNodeI | undefined {
+ for (const node of tree) {
if (node.comment_view.comment.id === id) {
- return Some(node);
+ return node;
}
for (const child of node.children) {
- let res = searchCommentTree([child], id);
+ const res = searchCommentTree([child], id);
- if (res.isSome()) {
+ if (res) {
return res;
}
}
}
- return None;
+ return undefined;
}
export const colorList: string[] = [
}
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}`;
}
return typeof window !== "undefined";
}
-export function setIsoData<Type1, Type2, Type3, Type4, Type5>(
- context: any,
- cls1?: ClassConstructor<Type1>,
- cls2?: ClassConstructor<Type2>,
- cls3?: ClassConstructor<Type3>,
- cls4?: ClassConstructor<Type4>,
- cls5?: ClassConstructor<Type5>
-): IsoData {
+export function setIsoData(context: any): IsoData {
// If its the browser, you need to deserialize the data from the window
if (isBrowser()) {
- let json = window.isoData;
- let routeData = json.routeData;
- let routeDataOut: any[] = [];
-
- // Can't do array looping because of specific type constructor required
- if (routeData[0]) {
- routeDataOut[0] = convertWindowJson(cls1, routeData[0]);
- }
- if (routeData[1]) {
- routeDataOut[1] = convertWindowJson(cls2, routeData[1]);
- }
- if (routeData[2]) {
- routeDataOut[2] = convertWindowJson(cls3, routeData[2]);
- }
- if (routeData[3]) {
- routeDataOut[3] = convertWindowJson(cls4, routeData[3]);
- }
- if (routeData[4]) {
- routeDataOut[4] = convertWindowJson(cls5, routeData[4]);
- }
- let site_res = convertWindowJson(GetSiteResponse, json.site_res);
-
- let isoData: IsoData = {
- path: json.path,
- site_res,
- routeData: routeDataOut,
- };
- return isoData;
+ return window.isoData;
} else return context.router.staticContext;
}
-/**
- * Necessary since window ISOData can't store function types like Option
- */
-export function convertWindowJson<T>(cls: ClassConstructor<T>, data: any): T {
- return deserialize(cls, serialize(data));
-}
-
-export function wsSubscribe(parseMessage: any): Subscription {
- 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;
- }
-}
-
moment.updateLocale("en", {
relativeTime: {
future: "in %s",
});
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
- .map(f => f.linked.length > 0)
- .unwrapOr(false);
+ return isoData.site_res.site_view.local_site.federation_enabled;
}
-export interface ChoicesValue {
+export interface Choice {
value: string;
label: string;
+ disabled?: boolean;
+}
+
+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): ChoicesValue {
- let choice: ChoicesValue = {
+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 = new Search({
+function fetchSearchResults(q: string, type_: SearchType) {
+ const form: Search = {
q,
- type_: Some(SearchType.Communities),
- sort: Some(SortType.TopAll),
- listing_type: Some(ListingType.All),
- page: Some(1),
- limit: Some(fetchLimit),
- community_id: None,
- community_name: None,
- creator_id: None,
- auth: auth(false).ok(),
- });
- let client = new LemmyHttp(httpBase);
- return client.search(form);
+ type_,
+ sort: "TopAll",
+ listing_type: "All",
+ page: 1,
+ limit: fetchLimit,
+ auth: myAuth(),
+ };
+
+ 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 = new Search({
- q,
- type_: Some(SearchType.Users),
- sort: Some(SortType.TopAll),
- listing_type: Some(ListingType.All),
- page: Some(1),
- limit: Some(fetchLimit),
- community_id: None,
- community_name: None,
- creator_id: None,
- auth: auth(false).ok(),
- });
- let client = new LemmyHttp(httpBase);
- return client.search(form);
-}
-
-export const choicesConfig = {
- shouldSort: false,
- searchResultLimit: fetchLimit,
- classNames: {
- containerOuter: "choices custom-select px-0",
- containerInner:
- "choices__inner bg-secondary border-0 py-0 modlog-choices-font-size",
- input: "form-control",
- inputCloned: "choices__input--cloned",
- list: "choices__list",
- listItems: "choices__list--multiple",
- listSingle: "choices__list--single py-0",
- 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.unwrapOr(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 {
- let expires = ps.ban_expires;
+export function isBanned(ps: Person): boolean {
+ const expires = ps.ban_expires;
// Add Z to convert from UTC date
// TODO this check probably isn't necessary anymore
- if (expires.isSome()) {
- if (ps.banned && new Date(expires.unwrap() + "Z") > new Date()) {
+ 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 auth(throwErr = true): Result<string, string> {
- return UserService.Instance.auth(throwErr);
+export function myAuthRequired(): string {
+ return UserService.Instance.auth(true) ?? "";
}
export function enableDownvotes(siteRes: GetSiteResponse): boolean {
- return siteRes.site_view.map(s => s.site.enable_downvotes).unwrapOr(true);
+ return siteRes.site_view.local_site.enable_downvotes;
}
export function enableNsfw(siteRes: GetSiteResponse): boolean {
- return siteRes.site_view.map(s => s.site.enable_nsfw).unwrapOr(false);
+ return siteRes.site_view.local_site.enable_nsfw;
}
export function postToCommentSortType(sort: SortType): CommentSortType {
- if ([SortType.Active, SortType.Hot].includes(sort)) {
- return CommentSortType.Hot;
- } else if ([SortType.New, SortType.NewComments].includes(sort)) {
- return CommentSortType.New;
- } else if (sort == SortType.Old) {
- return CommentSortType.Old;
- } else {
- return CommentSortType.Top;
+ switch (sort) {
+ case "Active":
+ case "Hot":
+ return "Hot";
+ case "New":
+ case "NewComments":
+ return "New";
+ case "Old":
+ return "Old";
+ default:
+ return "Top";
}
}
-export function arrayGet<T>(arr: Array<T>, index: number): Result<T, string> {
- let out = arr.at(index);
- if (out == undefined) {
- return Err("Index undefined");
- } else {
- return Ok(out);
- }
-}
-
-export function myFirstDiscussionLanguageId(
- myUserInfo = UserService.Instance.myUserInfo
-): Option<number> {
- return myUserInfo.andThen(mui =>
- arrayGet(mui.discussion_languages, 0)
- .ok()
- .map(i => i.id)
- );
-}
-
export function canCreateCommunity(
siteRes: GetSiteResponse,
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- let adminOnly = siteRes.site_view
- .map(s => s.site.community_creation_admin_only)
- .unwrapOr(false);
+ 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 = UserService.Instance.myUserInfo
+ myUserInfo: MyUserInfo | undefined = UserService.Instance.myUserInfo
): boolean {
- return myUserInfo
- .map(
- mui =>
- mui.community_blocks
- .map(c => c.community.id)
- .includes(pv.community.id) ||
- mui.person_blocks.map(p => p.target.id).includes(pv.creator.id)
- )
- .unwrapOr(false);
+ 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.
pv: PostView,
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- let nsfw = pv.post.nsfw || pv.community.nsfw;
- return (
- !nsfw ||
- (nsfw &&
- myUserInfo
- .map(m => m.local_user_view.local_user.show_nsfw)
- .unwrapOr(false))
+ 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;
+ }
+}