+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,
CommunityModeratorView,
CommunityView,
+ CustomEmojiView,
GetSiteMetadata,
GetSiteResponse,
Language,
LemmyHttp,
- LemmyWebsocket,
- ListingType,
- PersonSafe,
- PersonViewSafe,
+ MyUserInfo,
+ Person,
+ PersonMentionView,
+ PersonView,
PostReportView,
PostView,
PrivateMessageReportView,
Search,
SearchType,
SortType,
- UploadImageResponse,
} from "lemmy-js-client";
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 { i18n, languages } from "./i18next";
-import { DataType, IsoData } from "./interfaces";
-import { UserService, WebSocketService } from "./services";
-
-var Tribute: any;
+import { getHttpBase } from "./env";
+import { i18n } from "./i18next";
+import {
+ CommentNodeI,
+ DataType,
+ IsoData,
+ RouteData,
+ VoteType,
+} from "./interfaces";
+import { HttpService, UserService } from "./services";
+import { RequestState } from "./services/HttpService";
+
+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 mentionDropdownFetchLimit = 10;
export const commentTreeMaxDepth = 8;
export const markdownFieldCharacterLimit = 50000;
+export const maxUploadImages = 20;
+export const concurrentImageUpload = 4;
+export const updateUnreadCountsInterval = 30000;
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
},
};
-const markdownItConfig: MarkdownIt.Options = {
- html: false,
- linkify: true,
- typographer: true,
-};
+export let md: MarkdownIt = new MarkdownIt();
-export const 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);
-
-export const 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)
- .disable("image");
+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}`);
export function canMod(
creator_id: number,
mods?: CommunityModeratorView[],
- admins?: PersonViewSafe[],
+ admins?: PersonView[],
myUserInfo = UserService.Instance.myUserInfo,
onSelf = false
): boolean {
.concat(mods?.map(m => m.moderator.id) ?? []) ?? [];
if (myUserInfo) {
- let myIndex = adminsThenMods.findIndex(
+ const myIndex = adminsThenMods.findIndex(
id => id == myUserInfo.local_user_view.person.id
);
if (myIndex == -1) {
export function canAdmin(
creatorId: number,
- admins?: PersonViewSafe[],
+ admins?: PersonView[],
myUserInfo = UserService.Instance.myUserInfo,
onSelf = false
): boolean {
return myUserInfo ? isMod(myUserInfo.local_user_view.person.id, mods) : false;
}
-export function isAdmin(creatorId: number, admins?: PersonViewSafe[]): boolean {
+export function isAdmin(creatorId: number, admins?: PersonView[]): boolean {
return admins?.map(a => a.person.id).includes(creatorId) ?? false;
}
mods?: CommunityModeratorView[],
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- let myId = myUserInfo?.local_user_view.person.id;
+ 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?: PersonViewSafe[],
+ admins?: PersonView[],
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- let myId = myUserInfo?.local_user_view.person.id;
+ const myId = myUserInfo?.local_user_view.person.id;
return myId == admins?.at(0)?.person.id && myId != creator_id;
}
const imageRegex = /(http)?s?:?(\/\/[^"']*\.(?:jpg|jpeg|gif|png|svg|webp))/;
const videoRegex = /(http)?s?:?(\/\/[^"']*\.(?:mp4|webm))/;
+const tldRegex = /([a-z0-9]+\.)*[a-z0-9]+\.[a-z]+/;
export function isImage(url: string) {
return imageRegex.test(url);
return !!new URL(str);
}
+export function validInstanceTLD(str: string) {
+ return tldRegex.test(str);
+}
+
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);
- };
-}
-
-export function getLanguages(
- override?: string,
- myUserInfo = UserService.Instance.myUserInfo
-): string[] {
- let myLang = myUserInfo?.local_user_view.local_user.interface_language;
- let lang = override || myLang || "browser";
-
- if (lang == "browser" && isBrowser()) {
- return getBrowserLanguages();
- } else {
- return [lang];
- }
-}
-
-function getBrowserLanguages(): string[] {
- // Intersect lemmy's langs, with the browser langs
- let langs = languages ? languages.map(l => l.code) : ["en"];
-
- // NOTE, mobile browsers seem to be missing this list, so append en
- let allowedLangs = navigator.languages
- .concat("en")
- .filter(v => langs.includes(v));
- return allowedLangs;
+ } as (...e: T) => R;
}
export async function fetchThemeList(): Promise<string[]> {
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");
);
}
-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,
}
}
-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,
});
- toast.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,
- 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);
- }
- },
- });
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: `/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 && { icon: info.icon }),
- });
-
- 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 ``;
},
- 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");
+ const 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}"/>`;
+ };
+ md.renderer.rules.table_open = function () {
+ return '<table class="table">';
+ };
+}
+
+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;
+ const communitiesResponse = await fetchCommunities(text);
+
+ return communitiesResponse.map(cv => ({
+ key: `!${cv.community.name}@${hostname(cv.community.actor_id)}`,
+ view: cv,
+ }));
}
-export function getListingTypeFromProps(
- props: any,
- defaultListingType: ListingType,
- myUserInfo = UserService.Instance.myUserInfo
-): ListingType {
- let myLt = myUserInfo?.local_user_view.local_user.default_listing_type;
- return props.match.params.listing_type
- ? routeListingTypeToEnum(props.match.params.listing_type)
- : myLt
- ? Object.values(ListingType)[myLt]
- : defaultListingType;
+export function getRecipientIdFromProps(props: any): number {
+ return props.match.params.recipient_id
+ ? Number(props.match.params.recipient_id)
+ : 1;
}
-export function getListingTypeFromPropsNoDefault(props: any): ListingType {
- return props.match.params.listing_type
- ? routeListingTypeToEnum(props.match.params.listing_type)
- : ListingType.Local;
+export function getIdFromProps(props: any): number | undefined {
+ const id = props.match.params.post_id;
+ return id ? Number(id) : undefined;
}
-export function getDataTypeFromProps(props: any): DataType {
- return props.match.params.data_type
- ? routeDataTypeToEnum(props.match.params.data_type)
- : DataType.Post;
+export function getCommentIdFromProps(props: any): number | undefined {
+ const id = props.match.params.comment_id;
+ return id ? Number(id) : undefined;
}
-export function getSortTypeFromProps(
- props: any,
- myUserInfo = UserService.Instance.myUserInfo
-): SortType {
- let mySortType = myUserInfo?.local_user_view.local_user.default_sort_type;
- return props.match.params.sort
- ? routeSortTypeToEnum(props.match.params.sort)
- : mySortType
- ? Object.values(SortType)[mySortType]
- : SortType.Active;
+type ImmutableListKey =
+ | "comment"
+ | "comment_reply"
+ | "person_mention"
+ | "community"
+ | "private_message"
+ | "post"
+ | "post_report"
+ | "comment_report"
+ | "private_message_report"
+ | "registration_application";
+
+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 editComment(
+ data: CommentView,
+ comments: CommentView[]
+): CommentView[] {
+ return editListImmutable("comment", data, comments);
}
-export function getPageFromProps(props: any): number {
- return props.match.params.page ? Number(props.match.params.page) : 1;
+export function editCommentReply(
+ data: CommentReplyView,
+ replies: CommentReplyView[]
+): CommentReplyView[] {
+ return editListImmutable("comment_reply", data, replies);
}
-export function getRecipientIdFromProps(props: any): number {
- return props.match.params.recipient_id
- ? Number(props.match.params.recipient_id)
- : 1;
+interface WithComment {
+ comment: CommentI;
+ counts: CommentAggregates;
+ my_vote?: number;
+ saved: boolean;
}
-export function getIdFromProps(props: any): number | undefined {
- let id = props.match.params.post_id;
- return id ? Number(id) : undefined;
+export function editMention(
+ data: PersonMentionView,
+ comments: PersonMentionView[]
+): PersonMentionView[] {
+ return editListImmutable("person_mention", data, comments);
}
-export function getCommentIdFromProps(props: any): number | undefined {
- let id = props.match.params.comment_id;
- return id ? Number(id) : undefined;
+export function editCommunity(
+ data: CommunityView,
+ communities: CommunityView[]
+): CommunityView[] {
+ return editListImmutable("community", data, communities);
}
-export function getUsernameFromProps(props: any): string {
- return props.match.params.username;
+export function editPrivateMessage(
+ data: PrivateMessageView,
+ messages: PrivateMessageView[]
+): PrivateMessageView[] {
+ return editListImmutable("private_message", data, messages);
}
-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;
- }
+export function editPost(data: PostView, posts: PostView[]): PostView[] {
+ return editListImmutable("post", data, posts);
}
-export function saveCommentRes(data: CommentView, comments?: CommentView[]) {
- let found = comments?.find(c => c.comment.id == data.comment.id);
- if (found) {
- found.saved = data.saved;
- }
+export function editPostReport(
+ data: PostReportView,
+ reports: PostReportView[]
+) {
+ return editListImmutable("post_report", data, reports);
+}
+
+export function editCommentReport(
+ data: CommentReportView,
+ reports: CommentReportView[]
+): CommentReportView[] {
+ return editListImmutable("comment_report", data, reports);
+}
+
+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[]
+) {
+ return [
+ ...list.map(c =>
+ c.comment.id === comment.id
+ ? { ...c, comment, counts, saved, my_vote }
+ : c
+ ),
+ ];
}
export function updatePersonBlock(
data: BlockPersonResponse,
- myUserInfo = UserService.Instance.myUserInfo
+ myUserInfo: MyUserInfo | undefined = UserService.Instance.myUserInfo
) {
- let mui = myUserInfo;
- if (mui) {
+ if (myUserInfo) {
if (data.blocked) {
- mui.person_blocks.push({
- person: mui.local_user_view.person,
+ 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 {
- mui.person_blocks = mui.person_blocks.filter(
- i => i.target.id != data.person_view.person.id
+ 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 updateCommunityBlock(
data: BlockCommunityResponse,
- myUserInfo = UserService.Instance.myUserInfo
+ myUserInfo: MyUserInfo | undefined = UserService.Instance.myUserInfo
) {
- let mui = myUserInfo;
- if (mui) {
+ if (myUserInfo) {
if (data.blocked) {
- mui.community_blocks.push({
- person: mui.local_user_view.person,
+ 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 {
- mui.community_blocks = mui.community_blocks.filter(
- i => i.community.id != data.community_view.community.id
+ 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 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;
- }
- }
-}
-
-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 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 editPostFindRes(data: PostView, posts?: PostView[]) {
- let found = posts?.find(p => p.post.id == data.post.id);
- if (found) {
- editPostRes(data, found);
- }
-}
-
-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.featured_community = data.post.featured_community;
- post.post.featured_local = data.post.featured_local;
- post.post.body = data.post.body;
- post.post.locked = data.post.locked;
- post.saved = data.saved;
- }
-}
-
-// TODO possible to make these generic?
-export function updatePostReportRes(
- 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;
- }
-}
-
-export function updateCommentReportRes(
- 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;
- }
-}
-
-export function updatePrivateMessageReportRes(
- data: PrivateMessageReportView,
- reports?: PrivateMessageReportView[]
-) {
- 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;
- }
-}
-
-export function updateRegistrationApplicationRes(
- 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;
- }
-}
-
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) ?? 0;
- for (let comment_view of comments) {
- let depthI = getDepthFromComment(comment_view.comment) ?? 0;
- let depth = depthI ? depthI - depthOffset : 0;
- let node: CommentNodeI = {
+ 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[] = [];
+ const tree: CommentNodeI[] = [];
// if its a parent comment fetch, then push the first comment to the top node.
if (parentComment) {
- let cNode = 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);
+ for (const comment_view of comments) {
+ const child = map.get(comment_view.comment.id);
if (child) {
- let parent_id = getCommentParentId(comment_view.comment);
+ const parent_id = getCommentParentId(comment_view.comment);
if (parent_id) {
- let parent = map.get(parent_id);
+ const parent = map.get(parent_id);
// Necessary because blocked comment might not exist
if (parent) {
parent.children.push(child);
}
export function getCommentParentId(comment?: CommentI): number | undefined {
- let split = comment?.path.split(".");
+ const split = comment?.path.split(".");
// remove the 0
split?.shift();
}
export function getDepthFromComment(comment?: CommentI): number | undefined {
- let len = comment?.path.split(".").length;
+ 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,
};
- let parentId = getCommentParentId(cv.comment);
+ const parentId = getCommentParentId(cv.comment);
if (parentId) {
- let parent_comment = searchCommentTree(tree, parentId);
+ const parent_comment = searchCommentTree(tree, parentId);
if (parent_comment) {
node.depth = parent_comment.depth + 1;
parent_comment.children.unshift(node);
tree: CommentNodeI[],
id: number
): CommentNodeI | undefined {
- for (let node of tree) {
+ for (const node of tree) {
if (node.comment_view.comment.id === id) {
return node;
}
for (const child of node.children) {
- let res = searchCommentTree([child], id);
+ const res = searchCommentTree([child], id);
if (res) {
return res;
];
function hsl(num: number) {
- return `hsla(${num}, 35%, 50%, 1)`;
+ return `hsla(${num}, 35%, 50%, 0.5)`;
}
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(context: any): IsoData {
+export function setIsoData<T extends RouteData>(context: any): IsoData<T> {
// If its the browser, you need to deserialize the data from the window
if (isBrowser()) {
- let json = window.isoData;
- let routeData = json.routeData;
- let site_res = json.site_res;
-
- let isoData: IsoData = {
- path: json.path,
- site_res,
- routeData,
- };
- return isoData;
+ return window.isoData;
} else return context.router.staticContext;
}
-export function wsSubscribe(parseMessage: any): Subscription | undefined {
- 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 undefined;
- }
-}
-
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 {
- let linked = isoData.site_res.federated_instances?.linked;
- return linked ? linked.length > 0 : 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: 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: myAuth(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: myAuth(false),
- };
- 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 ?? 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;
- i18n.changeLanguage(getLanguages()[0]);
+export function initializeSite(site?: GetSiteResponse) {
+ UserService.Instance.myUserInfo = site?.my_user;
+ i18n.changeLanguage();
+ 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) {
}
}
-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 myAuth(throwErr = true): string | undefined {
- return UserService.Instance.auth(throwErr);
+export function myAuthRequired(): string {
+ return UserService.Instance.auth(true) ?? "";
}
export function enableDownvotes(siteRes: GetSiteResponse): boolean {
}
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 myFirstDiscussionLanguageId(
- allLanguages: Language[],
- siteLanguages: number[],
- myUserInfo = UserService.Instance.myUserInfo
-): number | undefined {
- return selectableLanguages(
- allLanguages,
- siteLanguages,
- false,
- false,
- myUserInfo
- ).at(0)?.id;
-}
-
export function canCreateCommunity(
siteRes: GetSiteResponse,
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- let adminOnly = siteRes.site_view.local_site.community_creation_admin_only;
+ 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?.community_blocks
pv: PostView,
myUserInfo = UserService.Instance.myUserInfo
): boolean {
- let nsfw = pv.post.nsfw || pv.community.nsfw;
- let myShowNsfw = myUserInfo?.local_user_view.local_user.show_nsfw ?? 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?.at(Math.floor(Math.random() * list.length));
+export function getRandomFromList<T>(list: T[]): T | undefined {
+ return list.length == 0
+ ? undefined
+ : list.at(Math.floor(Math.random() * list.length));
}
/**
showSite?: boolean,
myUserInfo = UserService.Instance.myUserInfo
): Language[] {
- let allLangIds = allLanguages.map(l => l.id);
+ const allLangIds = allLanguages.map(l => l.id);
let myLangs = myUserInfo?.discussion_languages ?? allLangIds;
myLangs = myLangs.length == 0 ? allLangIds : myLangs;
- let siteLangs = siteLanguages.length == 0 ? allLangIds : siteLanguages;
+ const siteLangs = siteLanguages.length == 0 ? allLangIds : siteLanguages;
if (showAll) {
return allLanguages;
}
}
-export function uploadImage(image: File): Promise<UploadImageResponse> {
- const client = new LemmyHttp(httpBase);
+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<T[K]>;
+};
+
+function sleep(millis: number): Promise<void> {
+ return new Promise(resolve => setTimeout(resolve, millis));
+}
- return client.uploadImage({ image });
+/**
+ * Polls / repeatedly runs a promise, every X milliseconds
+ */
+export async function poll(promiseFn: any, millis: number) {
+ if (window.document.visibilityState !== "hidden") {
+ await promiseFn();
+ }
+ await sleep(millis);
+ return poll(promiseFn, millis);
}
projects / lemmy-ui.git / blobdiff