31 |
37 | );
38 | };
39 |
40 | export default observer((props: IProps) => {
41 | const state = useLocalObservable(() => ({
42 | pending: true,
43 | }));
44 |
45 | React.useEffect(() => {
46 | setTimeout(() => {
47 | state.pending = false;
48 | }, 500);
49 | }, [state]);
50 |
51 | if (state.pending) {
52 | return null;
53 | }
54 |
55 | return
32 |
36 |
33 |
35 |
5 |
6 | ·
7 |
8 |
9 | );
10 |
--------------------------------------------------------------------------------
/src/components/ButtonProgress.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { CircularProgress } from '@mui/material';
3 | import { MdDone } from 'react-icons/md';
4 | import { observer, useLocalObservable } from 'mobx-react-lite';
5 | import { action } from 'mobx';
6 |
7 | interface IProps {
8 | size?: number
9 | color?: string
10 | isDoing: boolean
11 | isDone?: boolean
12 | noMargin?: boolean
13 | fixedDone?: boolean
14 | }
15 |
16 | const ButtonProgress = observer((props: IProps) => {
17 | const state = useLocalObservable(() => ({
18 | isShowDone: false,
19 | isShowDoneTimer: 0,
20 | }));
21 |
22 | React.useEffect(action(() => {
23 | if (props.isDone) {
24 | state.isShowDone = true;
25 | if (!props.fixedDone) {
26 | state.isShowDoneTimer = window.setTimeout(action(() => {
27 | state.isShowDone = false;
28 | }), 1500);
29 | }
30 | }
31 | }), [props.isDone]);
32 |
33 | React.useEffect(() => () => {
34 | window.clearTimeout(state.isShowDoneTimer);
35 | }, []);
36 |
37 | const { isDoing, color = 'text-white', size = 12 } = props;
38 | const { isShowDone } = state;
39 |
40 | if (isDoing) {
41 | return (
42 |
43 |
36 |
);
48 | }
49 |
50 | return
45 | {groupName.trim().substring(0, 1)}
46 |
47 |
14 | {urls.map((url: string, index: number) => (
15 |
35 | );
36 | };
37 |
--------------------------------------------------------------------------------
/src/components/Loading.tsx:
--------------------------------------------------------------------------------
1 | import React, { useMemo } from 'react';
2 | import { CircularProgress } from '@mui/material';
3 | import { styled } from '@mui/material/styles';
4 |
5 | export default (props: { size?: number, color?: string }) => {
6 | const { size } = props;
7 |
8 | const Bottom = useMemo(() => styled(CircularProgress)({
9 | color: props.color,
10 | opacity: 0.3,
11 | }), [props.color]);
12 |
13 | const Top = useMemo(() => styled(CircularProgress)({
14 | color: props.color,
15 | animationDuration: '550ms',
16 | position: 'absolute',
17 | left: 0,
18 | }), [props.color]);
19 |
20 | return (
21 | {
18 | openPhotoSwipe({
19 | image: urls,
20 | index,
21 | });
22 | }}
23 | >
24 |
32 |
33 | ))}
34 |
22 |
41 | );
42 | };
43 |
--------------------------------------------------------------------------------
/src/components/MiddleTruncate.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { Tooltip } from '@mui/material';
3 | import copy from 'copy-to-clipboard';
4 | import { observer } from 'mobx-react-lite';
5 | import { useStore } from 'store';
6 | import { lang } from 'utils/lang';
7 |
8 | interface IProps {
9 | string: string
10 | length: number
11 | }
12 |
13 | export default observer((props: IProps) => {
14 | const { snackbarStore } = useStore();
15 | const { string, length } = props;
16 |
17 | if (!string) {
18 | return null;
19 | }
20 |
21 | return (
22 |
23 |
35 |
40 | {
23 | copy(string);
24 | snackbarStore.show({
25 | message: lang.copied,
26 | });
27 | }}
28 | >
29 |
36 |
41 |
42 | );
43 | });
44 |
--------------------------------------------------------------------------------
/src/components/Page.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import Loading from 'components/Loading';
3 |
4 | interface IProps {
5 | title: string
6 | loading: boolean
7 | children?: React.ReactNode
8 | }
9 |
10 | export default (props: IProps) => (
11 | {`${string.slice(
37 | 0,
38 | length,
39 | )}......${string.slice(-length)}`}
40 |
12 |
30 | );
31 |
--------------------------------------------------------------------------------
/src/components/PageLoading.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { observer } from 'mobx-react-lite';
3 | import Loading from 'components/Loading';
4 | import { useStore } from 'store';
5 | import { Fade } from '@mui/material';
6 |
7 | export default observer(() => {
8 | const { modalStore } = useStore();
9 |
10 | if (!modalStore.pageLoading.open) {
11 | return null;
12 | }
13 |
14 | return (
15 |
13 | {props.loading && (
14 |
29 |
15 |
17 | )}
18 | {!props.loading && (
19 |
20 |
27 | )}
28 |
21 | {props.title}
22 |
23 |
24 |
26 | {props.children}
25 |
21 |
22 |
26 |
27 | );
28 | });
29 |
--------------------------------------------------------------------------------
/src/components/PasswordInput.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { observer, useLocalObservable } from 'mobx-react-lite';
3 | import { TextField, TextFieldProps, IconButton, InputAdornment } from '@mui/material';
4 | import { MdVisibility, MdVisibilityOff } from 'react-icons/md';
5 |
6 | export default observer((props: TextFieldProps) => {
7 | const state = useLocalObservable(() => ({
8 | showPassword: false,
9 | }));
10 |
11 | return (
12 |
23 |
25 |
14 | 内测版
15 |
16 |
21 |
33 | );
34 | });
35 |
--------------------------------------------------------------------------------
/src/components/Video/index.css:
--------------------------------------------------------------------------------
1 | .plyr.plyr--stopped .plyr__controls { display: none }
2 |
3 | .plyr-container video,
4 | .plyr-container.plyr__poster {
5 | border-radius: 12px;
6 | }
7 |
8 | .plyr-container.rect,
9 | .plyr-container.rect video,
10 | .plyr-container.rect .plyr__video-wrapper {
11 | width: 290px !important;
12 | height: 163px !important;
13 | }
14 |
15 | .plyr-container.rect-md,
16 | .plyr-container.rect-md video,
17 | .plyr-container.rect-md .plyr__video-wrapper {
18 | width: 460px !important;
19 | height: 258px !important;
20 | }
21 |
22 | .plyr-container.square,
23 | .plyr-container.square video,
24 | .plyr-container.square .plyr__video-wrapper {
25 | width: 290px !important;
26 | height: 290px !important;
27 | }
28 |
29 | .plyr-container.square-md,
30 | .plyr-container.square-md video,
31 | .plyr-container.square-md .plyr__video-wrapper {
32 | width: 460px !important;
33 | height: 460px !important;
34 | }
35 |
36 | .plyr--video,
37 | .plyr__video-wrapper {
38 | border-radius: 12px;
39 | }
40 |
41 | .plyr__control--overlaid {
42 | background: rgba(0,0,0,0.3) !important;
43 | border: 1px solid #fff;
44 | }
45 |
46 | .plyr--full-ui input[type=range] {
47 | color: white !important;
48 | }
49 |
50 | .plyr__control:hover {
51 | background: transparent !important;
52 | }
--------------------------------------------------------------------------------
/src/components/index.ts:
--------------------------------------------------------------------------------
1 | export * from './Video';
2 | export { default as Avatar } from './Avatar';
3 | export { default as BottomLine } from './BottomLine';
4 | export { default as ContentSyncStatus } from './ContentSyncStatus';
5 | export { default as Dialog } from './Dialog';
6 | export { default as Editor } from './Editor';
7 | export { default as Images } from './Images';
8 | export { default as Loading } from './Loading';
9 | export { default as TrxInfo } from './TrxInfo';
10 | export { default as UserCard } from './UserCard';
11 |
--------------------------------------------------------------------------------
/src/hooks/addGroups.tsx:
--------------------------------------------------------------------------------
1 | import { store } from 'store';
2 | import { IGroup, GroupUpdatedStatus } from 'apis/group';
3 | import { differenceInSeconds, differenceInHours } from 'date-fns';
4 | import getTimestampFromBlockTime from 'utils/getTimestampFromBlockTime';
5 |
6 | const getUpdatedStatus = (latestUpdated: number) => {
7 | if (differenceInSeconds(Date.now(), new Date(latestUpdated)) < 60) {
8 | return GroupUpdatedStatus.ACTIVE;
9 | } if (differenceInHours(Date.now(), new Date(latestUpdated)) < 24) {
10 | return GroupUpdatedStatus.RECENTLY;
11 | }
12 | return GroupUpdatedStatus.SLEEPY;
13 | };
14 |
15 | export default (groups: IGroup[]) => {
16 | const { latestStatusStore, groupStore } = store;
17 | const derivedGroups = (groups ?? []).map((group) => {
18 | const latestStatus = latestStatusStore.map[group.group_id] || latestStatusStore.DEFAULT_LATEST_STATUS;
19 | group.updatedStatus = getUpdatedStatus(Math.max(latestStatus.lastUpdated || 0, getTimestampFromBlockTime(group.last_updated)));
20 | return group;
21 | });
22 | groupStore.addGroups(derivedGroups);
23 | };
24 |
--------------------------------------------------------------------------------
/src/hooks/fetchGroups.tsx:
--------------------------------------------------------------------------------
1 | import GroupApi from 'apis/group';
2 | import addGroups from 'hooks/addGroups';
3 |
4 | export default async () => {
5 | try {
6 | const { groups } = await GroupApi.fetchMyGroups();
7 | addGroups(groups ?? []);
8 | } catch (err) {
9 | console.error(err);
10 | }
11 | };
12 |
--------------------------------------------------------------------------------
/src/hooks/useAnchorClick.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { shell } from 'electron';
3 |
4 | export default () => {
5 | React.useEffect(() => {
6 | const body = document.querySelector('body')!;
7 | if (body) {
8 | body.onclick = (e) => {
9 | const target = e.target as HTMLElement;
10 | if (target && target.tagName === 'A') {
11 | e.preventDefault();
12 | const href = target.getAttribute('href');
13 | if (href && href.startsWith('http')) {
14 | shell.openExternal(href);
15 | }
16 | }
17 | };
18 | }
19 | }, []);
20 | };
21 |
--------------------------------------------------------------------------------
/src/hooks/useAppBadgeCount.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { useStore } from 'store';
3 | import { sum } from 'lodash';
4 | import { ipcRenderer } from 'electron';
5 |
6 | export default () => {
7 | const { groupStore, latestStatusStore, nodeStore } = useStore();
8 | const { ids } = groupStore;
9 | const badgeCount = sum(
10 | ids.map(
11 | (groupId: string) => {
12 | const latestStatus = latestStatusStore.map[groupId] || latestStatusStore.DEFAULT_LATEST_STATUS;
13 | return latestStatus.unreadCount + sum(Object.values(latestStatus.notificationUnreadCountMap || {}));
14 | },
15 | ),
16 | );
17 |
18 | React.useEffect(() => {
19 | ipcRenderer.send('set-badge-count', nodeStore.connected ? badgeCount : 0);
20 | }, [badgeCount, nodeStore.connected]);
21 | };
22 |
--------------------------------------------------------------------------------
/src/hooks/useAppLaunchTime.tsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rumsystem/rum-app/d33578000c85f1af6bd7c704685dbc06eb3eae55/src/hooks/useAppLaunchTime.tsx
--------------------------------------------------------------------------------
/src/hooks/useCanIPost.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { useStore } from 'store';
3 | import useCheckPermission from 'hooks/useCheckPermission';
4 | import { lang } from 'utils/lang';
5 | import { GroupStatus } from 'apis/group';
6 |
7 | export default () => {
8 | const { snackbarStore, groupStore } = useStore();
9 | const checkPermission = useCheckPermission();
10 |
11 | return React.useCallback(async (groupId: string, options?: {
12 | ignoreGroupStatus: boolean
13 | }) => {
14 | const group = groupStore.map[groupId];
15 | if (!group) {
16 | snackbarStore.show({
17 | message: lang.notFound(lang.group),
18 | type: 'error',
19 | });
20 | throw new Error(lang.beBannedTip);
21 | }
22 |
23 | if (!options || !options.ignoreGroupStatus) {
24 | if (group.group_status === GroupStatus.SYNC_FAILED) {
25 | snackbarStore.show({
26 | message: lang.syncFailedTipForSubmit,
27 | type: 'error',
28 | });
29 | throw new Error(lang.syncFailedTipForSubmit);
30 | }
31 | }
32 |
33 | if (!await checkPermission(
34 | {
35 | groupId: group.group_id,
36 | publisher: group.user_pubkey,
37 | trxType: 'POST',
38 | },
39 | )) {
40 | snackbarStore.show({
41 | message: lang.beBannedTip,
42 | type: 'error',
43 | });
44 | throw new Error(lang.beBannedTip);
45 | }
46 | }, []);
47 | };
48 |
--------------------------------------------------------------------------------
/src/hooks/useCheckPaidGroupAnounce.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { IGroup } from 'apis/group';
3 | import {
4 | isPublicGroup,
5 | isNoteGroup,
6 | } from 'store/selectors/group';
7 | import MVMApi, { ICoin } from 'apis/mvm';
8 | import { formatEther, Contract } from 'ethers';
9 | import * as ContractUtils from 'utils/contract';
10 |
11 | export default () => React.useCallback(async (group: IGroup) => {
12 | if (isPublicGroup(group)
13 | || isNoteGroup(group)
14 | ) {
15 | return true;
16 | }
17 | try {
18 | const res = await MVMApi.coins();
19 | const coins = Object.values(res.data).filter((coin) => coin.rumSymbol !== 'RUM') as ICoin[];
20 |
21 | const contract = new Contract(ContractUtils.PAID_GROUP_CONTRACT_ADDRESS, ContractUtils.PAID_GROUP_ABI, ContractUtils.provider);
22 | const groupDetail = await contract.getPrice(ContractUtils.uuidToBigInt(group.group_id));
23 |
24 | const amount = formatEther(groupDetail.amount);
25 | const rumSymbol = coins.find((coin) => coin.rumAddress === groupDetail.tokenAddr)?.rumSymbol || '';
26 |
27 | if (+amount > 0 && rumSymbol) {
28 | return true;
29 | }
30 | return false;
31 | } catch (_) {
32 | return false;
33 | }
34 | }, []);
35 |
--------------------------------------------------------------------------------
/src/hooks/useCheckPermission.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import AuthApi, { TrxType } from 'apis/auth';
3 |
4 | interface IOptions {
5 | groupId: string
6 | publisher: string
7 | trxType: TrxType
8 | }
9 |
10 | export default () => React.useCallback(async ({
11 | groupId,
12 | publisher,
13 | trxType,
14 | }: IOptions) => {
15 | const followingRule = await AuthApi.getFollowingRule(groupId, trxType);
16 | if (followingRule.AuthType === 'FOLLOW_ALW_LIST') {
17 | const allowList = await AuthApi.getAllowList(groupId) || [];
18 | return allowList.some((item) => item.Pubkey === publisher);
19 | }
20 | if (followingRule.AuthType === 'FOLLOW_DNY_LIST') {
21 | const denyList = await AuthApi.getDenyList(groupId) || [];
22 | return !denyList.some((item) => item.Pubkey === publisher);
23 | }
24 | return true;
25 | }, []);
26 |
--------------------------------------------------------------------------------
/src/hooks/useCheckPrivatePermission.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { IGroup } from 'apis/group';
3 | import UserApi from 'apis/user';
4 | import {
5 | isGroupOwner,
6 | isPublicGroup,
7 | isNoteGroup,
8 | } from 'store/selectors/group';
9 |
10 | export default () => React.useCallback(async (group: IGroup) => {
11 | if (isPublicGroup(group)
12 | || isGroupOwner(group)
13 | || isNoteGroup(group)
14 | ) {
15 | return true;
16 | }
17 | try {
18 | const ret = await UserApi.fetchUser(group.group_id, group.user_pubkey);
19 | return ret.Result === 'APPROVED';
20 | } catch (_) {
21 | return false;
22 | }
23 | }, []);
24 |
--------------------------------------------------------------------------------
/src/hooks/useChecking/index.tsx:
--------------------------------------------------------------------------------
1 | import useCheckingAnnouncedUsers from './useCheckingAnnouncedUsers';
2 |
3 | export default () => {
4 | const SECONDS = 1000;
5 |
6 | useCheckingAnnouncedUsers(20 * SECONDS);
7 | };
8 |
--------------------------------------------------------------------------------
/src/hooks/useCleanLocalData.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import useDatabase from 'hooks/useDatabase';
3 | import sleep from 'utils/sleep';
4 | import { lang } from 'utils/lang';
5 | import { useStore } from 'store';
6 | import ElectronCurrentNodeStore from 'store/electronCurrentNodeStore';
7 | import electronApiConfigHistoryStore from 'store/electronApiConfigHistoryStore';
8 |
9 | export default () => {
10 | const { confirmDialogStore, nodeStore } = useStore();
11 | const database = useDatabase();
12 |
13 | return React.useCallback(() => {
14 | confirmDialogStore.show({
15 | content: lang.confirmToClearCacheData,
16 | okText: lang.yes,
17 | isDangerous: true,
18 | ok: async () => {
19 | if (confirmDialogStore.loading) {
20 | return;
21 | }
22 |
23 | confirmDialogStore.setLoading(true);
24 |
25 | if (process.env.NODE_ENV !== 'development') { await sleep(500); }
26 |
27 | nodeStore.setQuitting(true);
28 | nodeStore.setConnected(false);
29 |
30 | if (process.env.NODE_ENV !== 'development') { await sleep(500); }
31 |
32 | ElectronCurrentNodeStore.getStore().clear();
33 | electronApiConfigHistoryStore.getStore()?.clear();
34 |
35 | if (process.env.NODE_ENV !== 'development') { await sleep(500); }
36 |
37 | await database.delete();
38 |
39 | if (process.env.NODE_ENV !== 'development') { await sleep(500); }
40 | window.location.reload();
41 | },
42 | });
43 | }, [database]);
44 | };
45 |
--------------------------------------------------------------------------------
/src/hooks/useCloseNode.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { useStore } from 'store';
3 | import * as Quorum from 'utils/quorum';
4 |
5 | export default () => {
6 | const { nodeStore } = useStore();
7 |
8 | return React.useCallback(async () => {
9 | try {
10 | if (nodeStore.status.up) {
11 | nodeStore.setQuitting(true);
12 | nodeStore.setConnected(false);
13 | await Quorum.down();
14 | }
15 | } catch (err) {
16 | console.error(err);
17 | }
18 | }, []);
19 | };
20 |
--------------------------------------------------------------------------------
/src/hooks/useDatabase/contentStatus.ts:
--------------------------------------------------------------------------------
1 | export enum ContentStatus {
2 | synced = 'synced',
3 | syncing = 'syncing',
4 | }
5 |
--------------------------------------------------------------------------------
/src/hooks/useDatabase/index.tsx:
--------------------------------------------------------------------------------
1 | import Dexie from 'dexie';
2 | import Database, { getDatabaseName } from './database';
3 |
4 | let database = null as Database | null;
5 |
6 | export default () => database!;
7 |
8 | export const init = async (nodePublickey: string) => {
9 | if (database) {
10 | return database;
11 | }
12 |
13 | database = new Database(nodePublickey);
14 | await database.open();
15 |
16 | return database;
17 | };
18 |
19 | export const exists = async (nodePublickey: string) => {
20 | const databaseName = getDatabaseName(nodePublickey);
21 | const exists = await Dexie.exists(databaseName);
22 | return exists;
23 | };
24 |
--------------------------------------------------------------------------------
/src/hooks/useDatabase/models/emptyTrx.ts:
--------------------------------------------------------------------------------
1 | import type Database from 'hooks/useDatabase/database';
2 |
3 | export interface IDBEmptyTrx {
4 | groupId: string
5 | trxId: string
6 | timestamp: number
7 | lastChecked: number
8 | }
9 |
10 | export enum Order {
11 | desc,
12 | hot,
13 | }
14 |
15 | export const DEFAULT_SUMMARY = {
16 | hotCount: 0,
17 | commentCount: 0,
18 | likeCount: 0,
19 | dislikeCount: 0,
20 | };
21 |
22 | export const get = async (db: Database, where: { groupId: string, trxId: string }) => {
23 | const item = await db.emptyTrx.where(where).first();
24 | return item;
25 | };
26 |
27 | export const getByGroupId = async (db: Database, groupId: string) => {
28 | const items = await db.emptyTrx.where({ groupId }).toArray();
29 | return items;
30 | };
31 |
32 | export const getAll = async (db: Database) => {
33 | const items = await db.emptyTrx.toArray();
34 | return items;
35 | };
36 |
37 | export const put = async (db: Database, trx: IDBEmptyTrx) => {
38 | await db.emptyTrx.put(trx);
39 | };
40 |
41 | export const bulkPut = async (db: Database, trxs: Array
25 |
27 |
20 |
42 | );
43 | };
44 |
--------------------------------------------------------------------------------
/src/layouts/Content/Header/Notification/index.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import classNames from 'classnames';
3 | import { action } from 'mobx';
4 | import { observer, useLocalObservable } from 'mobx-react-lite';
5 | import { sum } from 'lodash';
6 | import { MdNotificationsNone } from 'react-icons/md';
7 | import { Badge } from '@mui/material';
8 | import useActiveGroupLatestStatus from 'store/selectors/useActiveGroupLatestStatus';
9 | import MessagesModal from './NotificationModal';
10 |
11 | interface Props {
12 | className?: string
13 | }
14 |
15 | export default observer((props: Props) => {
16 | const state = useLocalObservable(() => ({
17 | openMessageModal: false,
18 | }));
19 | const latestStatus = useActiveGroupLatestStatus();
20 |
21 | return (<>
22 |
28 | {!inited && (
29 | {
31 | setInited(true);
32 | store.nodeStore.setConnected(true);
33 | }}
34 | onInitCheckDone={() => setShow(true)}
35 | />
36 | )}
37 | {inited && (
38 |
41 |
19 |
40 | ));
41 |
--------------------------------------------------------------------------------
/src/layouts/Content/Sidebar/sortableState.tsx:
--------------------------------------------------------------------------------
1 | import { action, observable } from 'mobx';
2 |
3 | const state = observable({
4 | disabled: false,
5 | });
6 |
7 | const disableSortable = action(() => {
8 | state.disabled = true;
9 | });
10 | const enableSortable = action(() => {
11 | state.disabled = false;
12 | });
13 |
14 |
15 | export const sortableState = {
16 | state,
17 | disableSortable,
18 | enableSortable,
19 | };
20 |
--------------------------------------------------------------------------------
/src/layouts/Content/Welcome.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { observer } from 'mobx-react-lite';
3 | import Button from 'components/Button';
4 | import { joinGroup } from 'standaloneModals/joinGroup';
5 | import { createGroup } from 'standaloneModals/createGroup';
6 | import { lang } from 'utils/lang';
7 |
8 | export default observer(() => (
9 | props.setListType(ListType.icon)}
25 | >
26 |
29 | props.setListType(ListType.text)}
35 | >
36 |
39 |
10 |
28 | ));
29 |
--------------------------------------------------------------------------------
/src/layouts/Content/usePollingPaidGroupAnounce.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { useStore } from 'store';
3 | import useCheckPaidGroupAnounce from 'hooks/useCheckPaidGroupAnounce';
4 |
5 | export default () => {
6 | const { activeGroupStore, groupStore, snackbarStore } = useStore();
7 | const checkPaidGroupAnounce = useCheckPaidGroupAnounce();
8 |
9 | return React.useCallback(() => {
10 | const timer = setInterval(async () => {
11 | try {
12 | const group = groupStore.map[activeGroupStore.id];
13 | if (!group) {
14 | return;
15 | }
16 | const hasAnounce = await checkPaidGroupAnounce(group);
17 | if (hasAnounce) {
18 | activeGroupStore.setAnouncePaidGroupRequired(false);
19 | clearInterval(timer);
20 | snackbarStore.show({
21 | message: '您可以开始使用了',
22 | });
23 | }
24 | } catch (err) {
25 | console.log(err);
26 | }
27 | }, 2000);
28 | return timer;
29 | }, []);
30 | };
31 |
--------------------------------------------------------------------------------
/src/layouts/Content/usePollingPermission.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { useStore } from 'store';
3 | import useCheckPrivatePermission from 'hooks/useCheckPrivatePermission';
4 |
5 | export default () => {
6 | const { activeGroupStore, groupStore, snackbarStore } = useStore();
7 | const checkPrivatePermission = useCheckPrivatePermission();
8 |
9 | return React.useCallback(() => {
10 | const timer = setInterval(async () => {
11 | try {
12 | const group = groupStore.map[activeGroupStore.id];
13 | if (!group) {
14 | return;
15 | }
16 | const hasPermission = await checkPrivatePermission(group);
17 | if (hasPermission) {
18 | activeGroupStore.setPaidRequired(false);
19 | clearInterval(timer);
20 | snackbarStore.show({
21 | message: '您可以开始使用了',
22 | });
23 | }
24 | } catch (err) {
25 | console.log(err);
26 | }
27 | }, 2000);
28 | return timer;
29 | }, []);
30 | };
31 |
--------------------------------------------------------------------------------
/src/layouts/Main/Forum/OpenObjectEditor/icons.tsx:
--------------------------------------------------------------------------------
1 | import React, { useEffect } from 'react';
2 | import { createRoot } from 'react-dom/client';
3 | import {
4 | FaBold,
5 | FaItalic,
6 | FaHeading,
7 | FaQuoteLeft,
8 | FaListUl,
9 | FaListOl,
10 | FaImage,
11 | FaLink,
12 | FaEye,
13 | } from 'react-icons/fa';
14 |
15 | const div = document.createElement('div');
16 |
17 | export const iconMap = {} as Record{lang.welcomeToUseRum}
11 | {lang.youCanTry}
12 |
13 |
19 |
20 |
26 |
27 |
7 |
18 | );
19 |
--------------------------------------------------------------------------------
/src/layouts/Main/MoreHistoricalObjectEntry.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { Badge } from '@mui/material';
3 | import { FiChevronDown } from 'react-icons/fi';
4 |
5 | interface IProps {
6 | fetchUnreadObjects: () => void
7 | unreadCount: number
8 | }
9 |
10 | export default (props: IProps) => (
11 | {
10 | shell.openExternal('https://docs.prsdev.club/#/rum-app/');
11 | }}
12 | >
13 |
17 |
14 |
16 |
12 |
30 | );
31 |
--------------------------------------------------------------------------------
/src/layouts/Main/Note/ObjectEditor.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { observer } from 'mobx-react-lite';
3 | import useSubmitPost, { ISubmitObjectPayload } from 'hooks/useSubmitPost';
4 | import Editor from 'components/Editor';
5 | import { lang } from 'utils/lang';
6 |
7 | export default observer(() => {
8 | const submitPost = useSubmitPost();
9 |
10 | const submit = async (payload: ISubmitObjectPayload) => {
11 | try {
12 | await submitPost(payload);
13 | return true;
14 | } catch (_) {
15 | return false;
16 | }
17 | };
18 |
19 | return (
20 |
16 |
29 |
26 |
28 |
21 |
29 | );
30 | });
31 |
--------------------------------------------------------------------------------
/src/layouts/Main/Profile/index.scss:
--------------------------------------------------------------------------------
1 | .nickname-field {
2 | > div {
3 | border-color: #6f6f6f;
4 | }
5 | input {
6 | padding: 6px 32px 6px 6px !important;
7 | font-size: 16px;
8 | color: #333333;
9 | }
10 | .Mui-focused {
11 | input {
12 | color: #6f6f6f;
13 | }
14 | }
15 | .MuiOutlinedInput-notchedOutline {
16 | border-width: 1px !important;
17 | border-color: rgba(0, 0, 0, 0.23) !important;
18 | }
19 | }
20 |
21 | .save-nickname {
22 | width: 52px;
23 | height: 30px;
24 | background-color: #6f6f6f;
25 | border-radius: 40px;
26 | margin-left: 14px;
27 | color: #fff;
28 | display: flex;
29 | justify-content: center;
30 | align-items: center;
31 | cursor: pointer;
32 | }
33 |
--------------------------------------------------------------------------------
/src/layouts/Main/Timeline/ObjectEditorEntry.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { observer } from 'mobx-react-lite';
3 | import { useStore } from 'store';
4 | import classNames from 'classnames';
5 | import { BsPencil } from 'react-icons/bs';
6 | import openObjectEditor from './OpenObjectEditor';
7 |
8 | export default observer(() => {
9 | const { sidebarStore } = useStore();
10 |
11 | return (
12 |
13 |
26 | );
27 | });
28 |
--------------------------------------------------------------------------------
/src/layouts/Main/Timeline/PostAttachment.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { observer } from 'mobx-react-lite';
3 | import classNames from 'classnames';
4 | import { IDBPost } from 'hooks/useDatabase/models/posts';
5 | import { Video } from 'components/Video';
6 |
7 | interface IProps {
8 | className?: string
9 | attachment: IDBPost['attachment']
10 | }
11 |
12 | export const PostAttachment = observer((props: IProps) => {
13 | const video = props.attachment?.find((v) => v.type === 'Video');
14 |
15 | if (!video) { return null; }
16 |
17 | const poster = video.id
18 | ? `https://storage.googleapis.com/static.press.one/feed/videos/${video.id.replace(/\.mp4$/, '.jpg')}`
19 | : '';
20 | const url = video.id
21 | ? `https://storage.googleapis.com/static.press.one/feed/videos/${video.id}`
22 | : video.url!;
23 |
24 | return (
25 | {
19 | openObjectEditor();
20 | }}
21 | data-test-id="timeline-open-editor-button"
22 | >
23 |
25 |
30 |
37 |
38 | );
39 | });
40 |
--------------------------------------------------------------------------------
/src/layouts/Main/Timeline/helper.ts:
--------------------------------------------------------------------------------
1 | import LinkifyIt from 'linkify-it';
2 |
3 | const linkifyIt = new LinkifyIt(
4 | {
5 | 'mailto:': { validate: () => 0 },
6 | 'ftp:': { validate: () => 0 },
7 | }, {
8 | fuzzyLink: false,
9 | fuzzyEmail: false,
10 | },
11 | );
12 |
13 | export interface MatchItemPost { type: 'post', url: string, id: string }
14 | export interface MatchItemLink { type: 'link', url: string }
15 | export type MatchItem = MatchItemPost | MatchItemLink;
16 |
17 | export const matchContent = (content: string, skipForward = false): { item: MatchItem | null, content: string } => {
18 | const match = linkifyIt.match(content);
19 | if (!match) { return { item: null, content }; }
20 | const lastItem = match.at(-1);
21 |
22 | if (!lastItem) {
23 | return { item: null, content };
24 | }
25 |
26 | let url: null | URL = null;
27 | try {
28 | url = new URL(lastItem.url);
29 | } catch (e) {
30 | return { item: null, content };
31 | }
32 |
33 | if (!['http:', 'https:'].includes(url.protocol)) {
34 | return { item: null, content };
35 | }
36 |
37 | if (!skipForward && url.hostname.endsWith('feed.base.one')) {
38 | const postMatch = /^\/\/?posts\/([a-zA-Z0-9-]+)\/?$/i.exec(url.pathname);
39 | if (postMatch) {
40 | return {
41 | item: {
42 | type: 'post',
43 | id: postMatch[1]!,
44 | url: lastItem.url,
45 | },
46 | content: content.replace(lastItem.url, '').trim(),
47 | };
48 | }
49 | }
50 |
51 | return {
52 | item: {
53 | type: 'link',
54 | url: lastItem.url,
55 | },
56 | content,
57 | };
58 | };
59 |
--------------------------------------------------------------------------------
/src/layouts/TitleBar/index.sass:
--------------------------------------------------------------------------------
1 | $height-title-bar: 40px
2 | $height-menu-bar: 40px
3 | $height-total: $height-title-bar + $height-title-bar
4 |
5 | .app-title-bar-placeholder
6 | height: $height-menu-bar
7 | box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.16)
8 | position: relative
9 | z-index: 1
10 |
11 | .app-title-bar
12 | height: $height-title-bar
13 | -webkit-app-region: drag
14 | background-color: #6f6f6f
15 | background-size: auto 40px
16 | background-position: 148px 0
17 | background-repeat: no-repeat
18 | user-select: none
19 | z-index: 1000000000
20 |
21 | .app-logo
22 | $padding-left: 5px
23 | background-size: 148px auto
24 | background-repeat: no-repeat
25 | background-position: $padding-left -8px
26 | padding-left: $padding-left
27 | width: 148px + $padding-left
28 |
29 | .non-drag
30 | -webkit-app-region: none
31 |
32 | .apps-button-box
33 | height: $height-title-bar
34 |
35 | > div
36 | height: 40px
37 | width: 40px
38 |
39 | &.close-btn
40 | width: 48px
41 |
42 | .menu-bar
43 | height: $height-menu-bar
44 | // top: $height-title-bar
45 | top: 0
46 | z-index: 1
47 | user-select: none
48 |
49 | // .MuiDialog-root
50 | // top: $height-title-bar !important
51 |
--------------------------------------------------------------------------------
/src/layouts/index.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { StoreProvider } from 'store';
3 |
4 | import { isProduction, isStaging } from 'utils/env';
5 | import { ThemeRoot } from 'utils/theme';
6 | import { preloadAvatars } from 'utils/avatars';
7 | import { handleRumAppProtocol } from 'utils/handleRumAppProtocol';
8 |
9 | import SnackBar from 'components/SnackBar';
10 | import NotificationSlide from 'components/NotificationSlide';
11 | import ConfirmDialog from 'components/ConfirmDialog';
12 | import PageLoading from 'components/PageLoading';
13 | import PreviewVersion from 'components/PreviewVersion';
14 | import { ModalView } from 'standaloneModals/view';
15 |
16 | import Updater from '../Updater';
17 | import MyNodeInfoModal from './modals/MyNodeInfoModal';
18 | import App from './App';
19 |
20 |
21 | export default () => {
22 | React.useEffect(() => {
23 | preloadAvatars();
24 | return handleRumAppProtocol();
25 | }, []);
26 |
27 | return (
28 |
19 | {Array(props.total).fill(0).map((_, i) => (
20 | (),
10 | get components() {
11 | return Array.from(this.componentMap.values());
12 | },
13 | });
14 |
15 | const createModal = action(() => {
16 | state.id += 1;
17 | const id = state.id;
18 | return {
19 | addModal: action((name: string, props?: any) => {
20 | state.componentMap.set(id, {
21 | id,
22 | name,
23 | props,
24 | });
25 | }),
26 | destoryModal: action(() => {
27 | state.componentMap.delete(id);
28 | }),
29 | };
30 | });
31 |
32 | export const modalService = {
33 | state,
34 | createModal,
35 | };
36 |
--------------------------------------------------------------------------------
/src/standaloneModals/view.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import { observer } from 'mobx-react-lite';
3 | import { modalService } from './modal';
4 | import { JoinGroup } from './joinGroup/JoinGroup';
5 |
6 | export const ModalView = observer(() => (<>
7 | {modalService.state.components.map((v) => (
8 |
9 | {v.name === 'joinGroup' && (
11 | ))}
12 | ));
13 |
--------------------------------------------------------------------------------
/src/standaloneModals/wallet/searcher.tsx:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import classNames from 'classnames';
3 |
4 | import { lang } from 'utils/lang';
5 | import { TextField } from '@mui/material';
6 | import { IoSearch } from 'react-icons/io5';
7 |
8 | interface Props {
9 | width?: string
10 | keyword: string
11 | placeholder?: string
12 | onChange: (value: string) => void
13 | }
14 |
15 | export default (props: Props) => (
16 | = Record;
10 |
11 | const state = observable({
12 | lang: 'cn' as AllLanguages,
13 | });
14 |
15 | const createLangLoader = (langData: LangData) => {
16 | const langState = new Proxy({}, {
17 | get(_target, prop, _receiver) {
18 | const data = langData[state.lang];
19 | if (!data) {
20 | throw new Error(`${state.lang} language resource for this component is not defined.`);
21 | }
22 | return data.content[prop as keyof T];
23 | },
24 | });
25 |
26 | return langState as T;
27 | };
28 |
29 | const switchLang = action((lang: AllLanguages) => {
30 | state.lang = lang;
31 | localStorage.setItem(STORAGE_KEY, lang);
32 | ipcRenderer.send('change-language', lang);
33 | });
34 |
35 | const init = action(() => {
36 | let value = (localStorage.getItem(STORAGE_KEY) || 'cn') as AllLanguages;
37 | if (!allLang.includes(value)) {
38 | value = 'cn';
39 | }
40 | state.lang = value;
41 | ipcRenderer.send('change-language', value);
42 | });
43 |
44 | init();
45 |
46 | export const i18n = {
47 | state,
48 | createLangLoader,
49 | switchLang,
50 | };
51 |
--------------------------------------------------------------------------------
/src/store/notification.ts:
--------------------------------------------------------------------------------
1 | import type * as NotificationModel from 'hooks/useDatabase/models/notification';
2 | import { runInAction } from 'mobx';
3 |
4 | export function createNotificationStore() {
5 | return {
6 | idSet: new Set(),
7 |
8 | map: {} as Record,
9 |
10 | get notifications() {
11 | return Array.from(this.idSet).map((id) => this.map[id]);
12 | },
13 |
14 | addNotifications(
15 | notifications: NotificationModel.IDBNotification[],
16 | ) {
17 | runInAction(() => {
18 | for (const notification of notifications) {
19 | this.idSet.add(notification.Id || '');
20 | this.map[notification.Id || ''] = notification;
21 | }
22 | });
23 | },
24 |
25 | clear() {
26 | runInAction(() => {
27 | this.idSet.clear();
28 | this.map = {};
29 | });
30 | },
31 | };
32 | }
33 |
--------------------------------------------------------------------------------
/src/store/notificationSlide.ts:
--------------------------------------------------------------------------------
1 | interface ShowOptions {
2 | message?: string
3 | duration?: number
4 | type?: 'pending' | 'success' | 'failed'
5 | link?: {
6 | text: string
7 | url: string
8 | }
9 | }
10 |
11 | let timer: NodeJS.Timer;
12 |
13 | export function createNotificationSlideStore() {
14 | return {
15 | open: false,
16 | message: '',
17 | type: 'success',
18 | link: {
19 | text: '',
20 | url: '',
21 | },
22 | show(options?: ShowOptions) {
23 | clearTimeout(timer);
24 | const { message, duration = 3000, link, type = 'success' } = options ?? {};
25 | this.message = message ?? '';
26 | this.type = type ?? 'success';
27 | this.open = true;
28 | if (link) {
29 | this.link = link;
30 | }
31 | if (type === 'success') {
32 | timer = setTimeout(() => {
33 | this.close();
34 | }, duration);
35 | }
36 | },
37 | close() {
38 | this.open = false;
39 | },
40 | };
41 | }
42 |
--------------------------------------------------------------------------------
/src/store/relation.ts:
--------------------------------------------------------------------------------
1 | import * as RelationSummaryModel from 'hooks/useDatabase/models/relationSummaries';
2 |
3 | const getRelationSummaryKey = (v: RelationSummaryModel.IDBRelationSummary) => [
4 | v.groupId, v.from, v.to, v.type,
5 | ].join('-');
6 |
7 | export function createRelationStore() {
8 | return {
9 | relationMap: new Map(),
10 |
11 | get byGroupId() {
12 | return Array.from(this.relationMap.values()).reduce((p, c) => {
13 | const arr = p.get(c.groupId) ?? [];
14 | arr.push(c);
15 | p.set(c.groupId, arr);
16 | return p;
17 | }, new Map>());
18 | },
19 |
20 | addRelations(items: Array) {
21 | items.forEach((v) => {
22 | const key = getRelationSummaryKey(v);
23 | this.relationMap.set(key, v);
24 | });
25 | },
26 | };
27 | }
28 |
--------------------------------------------------------------------------------
/src/store/selectors/getLatestObject.ts:
--------------------------------------------------------------------------------
1 | import { Store } from 'store';
2 |
3 | export default (store: Store) => {
4 | const { activeGroupStore, latestStatusStore } = store;
5 | const latestStatus = latestStatusStore.map[activeGroupStore.id] || latestStatusStore.DEFAULT_LATEST_STATUS;
6 | return activeGroupStore.posts.find((o) => o.timestamp <= latestStatus.latestReadTimeStamp);
7 | };
8 |
--------------------------------------------------------------------------------
/src/store/selectors/group.ts:
--------------------------------------------------------------------------------
1 | import { IGroup } from 'apis/group';
2 | import { GROUP_TEMPLATE_TYPE } from 'utils/constant';
3 |
4 | export const isPublicGroup = (group: IGroup) => group.encryption_type.toLowerCase() === 'public';
5 |
6 | export const isPrivateGroup = (group: IGroup) => group.encryption_type.toLowerCase() === 'private';
7 |
8 | export const isTimelineGroup = (group: IGroup) => group.app_key === GROUP_TEMPLATE_TYPE.TIMELINE;
9 |
10 | export const isPostGroup = (group: IGroup) => group.app_key === GROUP_TEMPLATE_TYPE.POST;
11 |
12 | export const isNoteGroup = (group: IGroup) => group.app_key === GROUP_TEMPLATE_TYPE.NOTE;
13 |
14 | export const isCustomGroup = (group: IGroup) => group.app_key !== GROUP_TEMPLATE_TYPE.NOTE && group.app_key !== GROUP_TEMPLATE_TYPE.POST && group.app_key !== GROUP_TEMPLATE_TYPE.TIMELINE;
15 |
16 | export const isGroupOwner = (group: IGroup) => group.owner_pubkey === group.user_pubkey;
17 |
18 | export const getRole = (group: IGroup) => (isGroupOwner(group) ? 'owner' : 'user');
19 |
--------------------------------------------------------------------------------
/src/store/selectors/useActiveGroup.ts:
--------------------------------------------------------------------------------
1 | import { useStore } from 'store';
2 |
3 | export default () => {
4 | const { groupStore, activeGroupStore } = useStore();
5 | return groupStore.map[activeGroupStore.id] || {};
6 | };
7 |
--------------------------------------------------------------------------------
/src/store/selectors/useActiveGroupFollowingUserAddresses.ts:
--------------------------------------------------------------------------------
1 | import { useStore } from 'store';
2 |
3 | export default () => {
4 | const { activeGroupStore, relationStore, groupStore } = useStore();
5 | const group = groupStore.map[activeGroupStore.id];
6 | if (!group) { return []; }
7 | const relations = relationStore.byGroupId.get(group.group_id) ?? [];
8 | return relations
9 | .filter((v) => v.from === group.user_eth_addr && v.type === 'follow' && !!v.value)
10 | .map((v) => v.to);
11 | };
12 |
--------------------------------------------------------------------------------
/src/store/selectors/useActiveGroupLatestStatus.ts:
--------------------------------------------------------------------------------
1 | import { useStore } from 'store';
2 |
3 | export default () => {
4 | const { activeGroupStore, latestStatusStore } = useStore();
5 |
6 | return (
7 | latestStatusStore.map[activeGroupStore.id] || latestStatusStore.DEFAULT_LATEST_STATUS
8 | );
9 | };
10 |
--------------------------------------------------------------------------------
/src/store/selectors/useActiveGroupMutedUserAddress.ts:
--------------------------------------------------------------------------------
1 | import { useStore } from 'store';
2 |
3 | export default () => {
4 | const { activeGroupStore, relationStore, groupStore } = useStore();
5 | const group = groupStore.map[activeGroupStore.id];
6 | if (!group) { return []; }
7 | const relations = relationStore.byGroupId.get(group.group_id) ?? [];
8 | return relations
9 | .filter((v) => v.from === group.user_eth_addr && v.type === 'block' && !!v.value)
10 | .map((v) => v.to);
11 | };
12 |
--------------------------------------------------------------------------------
/src/store/selectors/useHasFrontHistoricalObject.ts:
--------------------------------------------------------------------------------
1 | import { useStore } from 'store';
2 |
3 | export default () => {
4 | const { activeGroupStore, latestStatusStore } = useStore();
5 | const latestStatus = latestStatusStore.map[activeGroupStore.id] || latestStatusStore.DEFAULT_LATEST_STATUS;
6 | return !!activeGroupStore.frontPost && activeGroupStore.frontPost.timestamp > latestStatus.latestPostTimeStamp;
7 | };
8 |
--------------------------------------------------------------------------------
/src/store/selectors/useIsCurrentGroupOwner.ts:
--------------------------------------------------------------------------------
1 | import { useStore } from 'store';
2 | import { isGroupOwner } from 'store/selectors/group';
3 |
4 | export default () => {
5 | const { groupStore, activeGroupStore } = useStore();
6 | return isGroupOwner(groupStore.map[activeGroupStore.id] || {});
7 | };
8 |
--------------------------------------------------------------------------------
/src/store/snackbar.ts:
--------------------------------------------------------------------------------
1 | import sleep from 'utils/sleep';
2 |
3 | interface ShowOptions {
4 | message?: string
5 | delayDuration?: number
6 | duration?: number
7 | type?: 'error'
8 | meta?: any
9 | }
10 |
11 | export function createSnackbarStore() {
12 | return {
13 | open: false,
14 | message: '',
15 | type: 'default',
16 | useNotificationStyle: false,
17 | meta: {},
18 | show(options?: ShowOptions) {
19 | (async () => {
20 | await sleep(options?.delayDuration ?? 150);
21 | this.close();
22 | const { message, duration = 1500, type, meta = {} } = options ?? {};
23 | this.message = message ?? '';
24 | this.type = type || 'default';
25 | const autoHideDuration = type === 'error' && duration === 1500 ? 2000 : duration;
26 | this.open = true;
27 | this.meta = meta;
28 | await sleep(autoHideDuration);
29 | this.close();
30 | })();
31 | },
32 | close() {
33 | this.open = false;
34 | },
35 | };
36 | }
37 |
--------------------------------------------------------------------------------
/src/styles/tailwind-base.sass:
--------------------------------------------------------------------------------
1 | @tailwind base
2 |
--------------------------------------------------------------------------------
/src/styles/tailwind.sass:
--------------------------------------------------------------------------------
1 | @tailwind utilities
2 |
3 | @layer utilities
4 | .flex-col
5 | display: flex
6 | flex-direction: column
7 |
8 | .break-words
9 | word-break: break-word
10 |
11 | .flex-center
12 | justify-content: center
13 | align-items: center
14 |
15 | .truncate-2
16 | display: -webkit-box
17 | overflow: hidden
18 | -webkit-line-clamp: 2
19 | -webkit-box-orient: vertical
20 |
21 | .truncate-3
22 | display: -webkit-box
23 | overflow: hidden
24 | -webkit-line-clamp: 3
25 | -webkit-box-orient: vertical
26 |
27 | .truncate-4
28 | display: -webkit-box
29 | overflow: hidden
30 | -webkit-line-clamp: 4
31 | -webkit-box-orient: vertical
32 |
33 | .truncate-5
34 | display: -webkit-box
35 | overflow: hidden
36 | -webkit-line-clamp: 5
37 | -webkit-box-orient: vertical
38 |
39 | .font-default
40 | font-family: 'color-emoji', 'Nunito Sans', 'PingFang SC', 'Hiragino Sans GB', 'Heiti SC', 'Source Han Sans SC', 'Source Han Sans', 'WenQuanYi Micro Hei', 'Microsoft YaHei UI', 'Microsoft YaHei', sans-serif
41 |
--------------------------------------------------------------------------------
/src/tests/index.ts:
--------------------------------------------------------------------------------
1 | import './setup-global';
2 | import path from 'path';
3 | import fs from 'fs/promises';
4 |
5 | const testMain = async () => {
6 | const names = process.argv.slice(2);
7 | try {
8 | const testBasePath = path.join(__dirname, 'tests');
9 | const tests = await fs.readdir(testBasePath);
10 | const filteredTests = tests.filter((v) => {
11 | if (!/\.tsx?$/.test(v)) { return false; }
12 | if (!names.length) { return true; }
13 | return names.some((n) => v.includes(n));
14 | });
15 | for (const file of filteredTests) {
16 | const testName = file.replace(/\.tsx?$/, '');
17 | const filePath = path.join(testBasePath, file);
18 | const test = (await import(filePath)).default;
19 | console.log(`\nrunning test: ${testName}`);
20 | await test();
21 | }
22 | } catch (e) {
23 | console.error(e);
24 | process.exit(1);
25 | }
26 | };
27 |
28 | testMain();
29 |
--------------------------------------------------------------------------------
/src/tests/setup.ts:
--------------------------------------------------------------------------------
1 | import path from 'path';
2 | import electron from 'electron';
3 | import { rimraf } from 'rimraf';
4 | import puppeteer from 'puppeteer-core';
5 | import expect from 'expect-puppeteer';
6 | import sleep from 'utils/sleep';
7 |
8 | export const setup = async () => {
9 | try {
10 | await rimraf(path.join(__dirname, 'userData'));
11 | } catch (err) {
12 | console.error(err);
13 | process.exit(1);
14 | }
15 |
16 | const app = await puppeteer.launch({
17 | executablePath: electron as any,
18 | env: {
19 | TEST_ENV: process.env.TEST_ENV!,
20 | devtool: 'true',
21 | },
22 | args: ['.'],
23 | headless: false,
24 | });
25 | const pages = await app.pages();
26 | const [page] = pages;
27 | await page.setViewport({ width: 1260, height: 740 });
28 |
29 | await sleep(5000);
30 |
31 | await Promise.any([
32 | expect(page).toMatchElement('.sidebar', {
33 | timeout: 10000,
34 | }),
35 | expect(page).toMatchElement('[data-test-id="welcome-page"]', {
36 | timeout: 10000,
37 | }),
38 | ]).catch((e) => {
39 | console.log('failed to load app');
40 | throw e;
41 | });
42 |
43 | return {
44 | app,
45 | page,
46 | destroy: async () => {
47 | await page.close();
48 | await app.close();
49 | },
50 | } as const;
51 | };
52 |
--------------------------------------------------------------------------------
/src/tests/tests/common/createGroup.ts:
--------------------------------------------------------------------------------
1 | import { Page } from 'puppeteer-core';
2 | import sleep from 'utils/sleep';
3 | import { GROUP_TEMPLATE_TYPE } from 'utils/constant';
4 |
5 | export const createGroup = async (page: Page, groupName: string, groupType: GROUP_TEMPLATE_TYPE) => {
6 | Promise.any([
7 | (async () => {
8 | await page.clickByTestId('sidebar-plus-button');
9 | await page.clickByTestId('sidebar-menu-item-create-group');
10 | })(),
11 | (async () => {
12 | await page.clickByTestId('welcome-page-create-group-button');
13 | })(),
14 | ]).catch((e) => {
15 | console.log('can\'t find create group button');
16 | throw e;
17 | });
18 |
19 | await page.clickByTestId(`group-type-${groupType}`);
20 | await page.clickByTestId('create-group-modal-next-step');
21 | await sleep(100);
22 | if (groupType !== GROUP_TEMPLATE_TYPE.NOTE) {
23 | await page.clickByTestId('create-group-modal-next-step');
24 | }
25 | await page.fillByTestId('create-group-name-input input', groupName);
26 | await page.clickByTestId('create-group-modal-confirm');
27 | await page.clickByTestId('create-group-confirm-modal-confirm');
28 | await sleep(5000);
29 | };
30 |
--------------------------------------------------------------------------------
/src/tests/tests/common/exitCurrentGroup.ts:
--------------------------------------------------------------------------------
1 | import { Page } from 'puppeteer-core';
2 |
3 | export const exitCurrentGroup = async (page: Page) => {
4 | await page.clickByTestId('group-menu-button');
5 | await page.clickByTestId('group-menu-exit-group-button');
6 | await page.clickByTestId('exit-group-dialog-confirm-button');
7 | };
8 |
--------------------------------------------------------------------------------
/src/tests/tests/common/groupInfoModal.ts:
--------------------------------------------------------------------------------
1 | import expect from 'expect-puppeteer';
2 | import { Page } from 'puppeteer-core';
3 | import sleep from 'utils/sleep';
4 |
5 | export const groupInfoModal = async (page: Page) => {
6 | page.clickByTestId('header-group-name');
7 | await sleep(1000);
8 | const close = await expect(page).toMatchElement('.group-info-modal [data-test-id="dialog-close-button"]');
9 | await sleep(1000);
10 | await close.click();
11 | await sleep(1000);
12 | await expect(page).not.toMatchElement('.group-info-modal');
13 | };
14 |
--------------------------------------------------------------------------------
/src/tests/tests/common/index.tsx:
--------------------------------------------------------------------------------
1 | export * from './createGroup';
2 | export * from './exitCurrentGroup';
3 | export * from './groupInfoModal';
4 | export * from './myGroupModal';
5 | export * from './nodeAndNetwork';
6 | export * from './shareGroup';
7 |
--------------------------------------------------------------------------------
/src/tests/tests/common/myGroupModal.ts:
--------------------------------------------------------------------------------
1 | import { Page } from 'puppeteer-core';
2 | import sleep from 'utils/sleep';
3 |
4 | export const myGroupModal = async (page: Page) => {
5 | await page.clickByTestId('sidebar-my-group-button');
6 | await sleep(1000);
7 | await page.matchByTestId('my-group-modal');
8 | await page.clickByTestId('my-group-modal-close');
9 | await sleep(1000);
10 | await page.notMatchByTestId('my-group-modal');
11 | };
12 |
--------------------------------------------------------------------------------
/src/tests/tests/common/nodeAndNetwork.ts:
--------------------------------------------------------------------------------
1 | import expect from 'expect-puppeteer';
2 | import { Page } from 'puppeteer-core';
3 | import sleep from 'utils/sleep';
4 |
5 | export const nodeAndNetowrk = async (page: Page) => {
6 | await page.clickByTestId('header-node-and-network');
7 | await sleep(500);
8 | await page.clickByTestId('node-and-network-node-params');
9 | await sleep(500);
10 | await expect(page).toClick('.node-params-modal [data-test-id="dialog-close-button"]');
11 | await sleep(500);
12 | await page.clickByTestId('node-and-network-network-status');
13 | await sleep(500);
14 | await expect(page).toClick('.network-info-modal [data-test-id="dialog-close-button"]');
15 | await sleep(500);
16 | await expect(page).toClick('.node-info-modal [data-test-id="dialog-close-button"]');
17 | await sleep(500);
18 | await expect(page).not.toMatchElement('.node-info-modal');
19 | };
20 |
--------------------------------------------------------------------------------
/src/tests/tests/common/shareGroup.ts:
--------------------------------------------------------------------------------
1 | import expect from 'expect';
2 | import { Page } from 'puppeteer-core';
3 | import sleep from 'utils/sleep';
4 |
5 | export const shareGroup = async (page: Page) => {
6 | await page.clickByTestId('header-share-group');
7 | const shareGroup = await page.matchByTestId('share-group-modal');
8 | await sleep(1000);
9 | const textarea = await shareGroup.matchByTestId('share-group-textarea');
10 | const content = await textarea.evaluate((e) => (e as HTMLTextAreaElement).value);
11 | expect(content).toBeTruthy();
12 | await shareGroup.clickByTestId('dialog-close-button');
13 | await sleep(1000);
14 | };
15 |
--------------------------------------------------------------------------------
/src/tests/tests/noteGroup.ts:
--------------------------------------------------------------------------------
1 | import expect from 'expect-puppeteer';
2 | import { format } from 'date-fns';
3 | import sleep from 'utils/sleep';
4 | import { GROUP_TEMPLATE_TYPE } from 'utils/constant';
5 | import { setup } from 'tests/setup';
6 | import { createGroup, exitCurrentGroup } from './common';
7 |
8 | export default async () => {
9 | const { page, destroy } = await setup();
10 | await createGroup(page, 'testgroup', GROUP_TEMPLATE_TYPE.NOTE);
11 | await page.matchByTestId('note-feed');
12 |
13 | const content = [
14 | format(new Date(), 'yyyy-MM-dd hh-mm:ss'),
15 | 'note-test-post',
16 | ].join('');
17 | await page.fillByTestId('note-editor textarea', content);
18 | await sleep(3000);
19 | await page.clickByTestId('editor-submit-button');
20 | await sleep(5000);
21 |
22 | await expect(page).toMatchElement('[data-test-id="note-object-item"] [data-test-id="synced-timeline-item-menu"]', {
23 | timeout: 30000,
24 | });
25 |
26 | await exitCurrentGroup(page);
27 |
28 | await expect(page).not.toMatchElement('.sidebar', {
29 | timeout: 10000,
30 | });
31 |
32 | await sleep(1000);
33 | await destroy();
34 | };
35 |
--------------------------------------------------------------------------------
/src/tests/tests/postGroup.ts:
--------------------------------------------------------------------------------
1 | import expect from 'expect-puppeteer';
2 | import { format } from 'date-fns';
3 | import sleep from 'utils/sleep';
4 | import { setup } from 'tests/setup';
5 | import { GROUP_TEMPLATE_TYPE } from 'utils/constant';
6 | import { createGroup, exitCurrentGroup } from './common';
7 |
8 | export default async () => {
9 | const { page, destroy } = await setup();
10 | await createGroup(page, 'testgroup', GROUP_TEMPLATE_TYPE.POST);
11 | await page.matchByTestId('post-feed');
12 |
13 | const content = [
14 | format(new Date(), 'yyyy-MM-dd hh-mm:ss'),
15 | 'forum-test-post',
16 | ].join('');
17 | await page.clickByTestId('forum-create-first-post-button');
18 | await sleep(1000);
19 | await page.fillByTestId('forum-post-title-input input', 'post title');
20 |
21 | await expect(page).toClick('.CodeMirror-line');
22 | page.keyboard.type(content);
23 | await sleep(2000);
24 |
25 | await page.clickByTestId('forum-post-submit-button');
26 | await sleep(5000);
27 |
28 | await expect(page).toMatchElement('[data-test-id="forum-object-item"] [data-test-id="synced-timeline-item-menu"]', {
29 | timeout: 30000,
30 | });
31 |
32 | await exitCurrentGroup(page);
33 |
34 | await expect(page).not.toMatchElement('.sidebar', {
35 | timeout: 10000,
36 | });
37 |
38 | await sleep(1000);
39 | await destroy();
40 | };
41 |
--------------------------------------------------------------------------------
/src/tests/types/puppeteer-core.d.ts:
--------------------------------------------------------------------------------
1 | import 'puppeteer-core';
2 | import { ExpectToClickOptions, ExpectTimingActions } from 'expect-puppeteer';
3 |
4 | declare module 'puppeteer-core' {
5 | interface CustomTestMethods {
6 | matchByTestId: (testId: string, options?: ExpectToClickOptions) => Promise
7 | notMatchByTestId: (testId: string, options?: ExpectToClickOptions) => Promise
8 | clickByTestId: (testId: string, options?: ExpectToClickOptions) => Promise
9 | /**
10 | * @param {string} [testId] - `"testId"` or `"testId subselector"`
11 | */
12 | fillByTestId: (testId: string, content: string, options?: ExpectTimingActions) => Promise
13 | }
14 | interface Page extends CustomTestMethods {}
15 | interface ElementHandle extends CustomTestMethods {}
16 | }
17 |
--------------------------------------------------------------------------------
/src/types/assets.d.ts:
--------------------------------------------------------------------------------
1 | declare module '*.svg' {
2 | const content: any;
3 | export default content;
4 | export const ReactComponent: React.ReactElement;
5 | }
6 |
7 | declare module '*.svg?react' {
8 | const content: React.FunctionComponent>;
9 | export default content;
10 | }
11 |
12 | declare module '*.png' {
13 | const content: any;
14 | export default content;
15 | }
16 |
17 | declare module '*.jpg' {
18 | const content: any;
19 | export default content;
20 | }
21 |
22 | declare module '*.sass?inline' {
23 | const content: string;
24 | export default content;
25 | }
26 |
--------------------------------------------------------------------------------
/src/types/axios.d.ts:
--------------------------------------------------------------------------------
1 | declare module 'axios/lib/adapters/http';
2 |
--------------------------------------------------------------------------------
/src/types/global.d.ts:
--------------------------------------------------------------------------------
1 | declare global {
2 | // const IS_E2E_TEST: string | undefined;
3 | }
4 |
5 | export {};
6 |
--------------------------------------------------------------------------------
/src/types/markdown-it-task-lists.d.ts:
--------------------------------------------------------------------------------
1 | declare module 'markdown-it-task-lists';
2 |
--------------------------------------------------------------------------------
/src/types/process.d.ts:
--------------------------------------------------------------------------------
1 | declare namespace NodeJS {
2 | interface ProcessEnv {
3 | TEST_ENV: string | undefined
4 | NODE_ENV: 'development' | 'production'
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/src/types/styled-jsx.d.ts:
--------------------------------------------------------------------------------
1 | import 'react';
2 |
3 | declare module 'react' {
4 | interface StyleHTMLAttributes extends HTMLAttributes {
5 | jsx?: boolean
6 | global?: boolean
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/src/types/wasm.d.ts:
--------------------------------------------------------------------------------
1 | declare module '*.wasm'
2 |
--------------------------------------------------------------------------------
/src/utils/PollingTask.ts:
--------------------------------------------------------------------------------
1 | interface PollingTaskParams {
2 | interval: number
3 | task: () => unknown
4 | }
5 |
6 | export class PollingTask {
7 | private task: () => unknown;
8 | private interval: number;
9 | private stopFlag = false;
10 | private advancePromiseResolve: (v?: unknown) => void = () => {};
11 |
12 | public constructor(params: PollingTaskParams) {
13 | this.task = params.task;
14 | this.interval = params.interval;
15 | this.start();
16 | }
17 |
18 | public stop() {
19 | this.stopFlag = true;
20 | }
21 |
22 | public advance() {
23 | this.advancePromiseResolve?.();
24 | }
25 |
26 | public changeInterval(interval: number) {
27 | this.interval = interval;
28 | }
29 |
30 | private async start() {
31 | for (;;) {
32 | if (this.stopFlag) { break; }
33 | try {
34 | await this.task();
35 | } catch (e) {
36 | console.error(e);
37 | }
38 | if (this.stopFlag) { break; }
39 | await this.waitInterval();
40 | }
41 | }
42 |
43 | private async waitInterval() {
44 | await new Promise((rs) => {
45 | this.advancePromiseResolve = rs;
46 | setTimeout(rs, this.interval);
47 | });
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/utils/ago.ts:
--------------------------------------------------------------------------------
1 | import { format } from 'date-fns';
2 | import { lang } from 'utils/lang';
3 |
4 | export default (blockTimeStamp: number, options: { trimmed?: boolean } = {}) => {
5 | if (!blockTimeStamp) {
6 | return '';
7 | }
8 | const timestamp = blockTimeStamp > 10 ** 14
9 | ? blockTimeStamp / 1000000
10 | : blockTimeStamp;
11 | const time = new Date(timestamp);
12 | const now = new Date().getTime();
13 | const past = new Date(time).getTime();
14 | const diffValue = now - past;
15 | const minute = 1000 * 60;
16 | const hour = minute * 60;
17 | const day = hour * 24;
18 | const _week = diffValue / (7 * day);
19 | const _day = diffValue / day;
20 | const _hour = diffValue / hour;
21 | const _min = diffValue / minute;
22 | let result = '';
23 | const isLastYear = new Date().getFullYear() > time.getFullYear();
24 | const isDiffDay = new Date().getDate() !== time.getDate();
25 | if (isLastYear && _week >= 15) {
26 | result = format(time, options.trimmed ? 'yyyy-MM-dd' : 'yyyy-MM-dd HH:mm');
27 | } else if (_day >= 1 || isDiffDay) {
28 | result = format(time, options.trimmed ? 'MM-dd' : 'MM-dd HH:mm');
29 | } else if (_hour >= 4) {
30 | result = format(time, 'HH:mm');
31 | } else if (_hour >= 1) {
32 | result = Math.floor(_hour) + lang.hoursAgo;
33 | } else if (_min >= 1) {
34 | result = Math.floor(_min) + lang.minutesAgo;
35 | } else {
36 | result = lang.justNow;
37 | }
38 | return result;
39 | };
40 |
--------------------------------------------------------------------------------
/src/utils/assets-custom-loader.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 |
3 | const rootPath = path.join(__dirname, '../..');
4 |
5 | module.exports = function assetsCustomLoader() {
6 | const filePath = this.resourcePath;
7 |
8 | if (process.env.NODE_ENV === 'development' || process.env.TEST_ENV) {
9 | const uri = `file://${filePath.replace(/\\/g, '/')}`;
10 | return `export default ${JSON.stringify(uri)};`;
11 | }
12 |
13 | const relativePath = filePath.replace(rootPath, '').replace(/\\/g, '/');
14 | return `export default \`file://\${process.resourcesPath.replace(/\\\\/g, '/')}${relativePath}\`;`;
15 | };
16 |
--------------------------------------------------------------------------------
/src/utils/cachePromise.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * 返回原函数，但该函数在连续多次调用时，首次调用未resolve时，返回缓存的 promise
3 | */
4 | export const cachePromiseHof = ) => unknown>(fn: T) => {
5 | let promise: null | Promise = null;
6 |
7 | return ((...args) => {
8 | if (promise) {
9 | return promise;
10 | }
11 | promise = Promise.resolve(fn(...args));
12 | promise.finally(() => {
13 | promise = null;
14 | });
15 | return promise;
16 | }) as T;
17 | };
18 |
--------------------------------------------------------------------------------
/src/utils/decimal.ts:
--------------------------------------------------------------------------------
1 | export default (num: string, n: number) => num.slice(0, num.indexOf('.') + 1 + n).replace(/\.*0+$/, '');
2 |
--------------------------------------------------------------------------------
/src/utils/digestMessage.ts:
--------------------------------------------------------------------------------
1 | import crypto from 'crypto';
2 |
3 | export const digestMessage = (message: string) => crypto.createHash('md5').update(message).digest('hex');
4 |
--------------------------------------------------------------------------------
/src/utils/domSelector.ts:
--------------------------------------------------------------------------------
1 | export const getPageElement = () =>
2 | document.querySelector('.layout-page')!;
3 |
--------------------------------------------------------------------------------
/src/utils/env.ts:
--------------------------------------------------------------------------------
1 | export const isDevelopment = process.env.NODE_ENV === 'development';
2 |
3 | export const isProduction = !isDevelopment;
4 |
5 | export const isStaging = process.env.BUILD_ENV === 'staging';
6 |
7 | export const isWindow = window.navigator.userAgent.includes('Windows NT');
8 |
--------------------------------------------------------------------------------
/src/utils/formatAmount.ts:
--------------------------------------------------------------------------------
1 | import decimal from './decimal';
2 |
3 | export default (num: string) => decimal(num, 8);
4 |
--------------------------------------------------------------------------------
/src/utils/formatPath.ts:
--------------------------------------------------------------------------------
1 | import { isWindow } from 'utils/env';
2 |
3 | export default (path: string, options: { truncateLength: number }) => {
4 | const _path = isWindow ? path.replaceAll('/', '\\') : path;
5 | return _path.length > options.truncateLength
6 | ? `...${_path.slice(-options.truncateLength)}`
7 | : _path;
8 | };
9 |
--------------------------------------------------------------------------------
/src/utils/getBase.ts:
--------------------------------------------------------------------------------
1 | export default () => {
2 | const { nodeStore } = (window as any).store;
3 | if (nodeStore.mode === 'EXTERNAL') {
4 | return nodeStore.apiConfig.origin;
5 | }
6 | return `http://127.0.0.1:${nodeStore.port}`;
7 | };
8 |
--------------------------------------------------------------------------------
/src/utils/getGroupIcon.ts:
--------------------------------------------------------------------------------
1 | import TimelineIcon from 'assets/template/template_icon_timeline.svg?react';
2 | import PostIcon from 'assets/template/template_icon_post.svg?react';
3 | import NotebookIcon from 'assets/template/template_icon_notebook.svg?react';
4 |
5 | import { GROUP_TEMPLATE_TYPE } from './constant';
6 |
7 | const groupIconMap = new Map>>([
8 | [GROUP_TEMPLATE_TYPE.TIMELINE, TimelineIcon],
9 | [GROUP_TEMPLATE_TYPE.POST, PostIcon],
10 | [GROUP_TEMPLATE_TYPE.NOTE, NotebookIcon],
11 | ]);
12 |
13 | export const getGroupIcon = (appKey: string) => {
14 | const GroupTypeIcon = groupIconMap.get(appKey) ?? TimelineIcon;
15 | return GroupTypeIcon;
16 | };
17 |
--------------------------------------------------------------------------------
/src/utils/getHotCount.ts:
--------------------------------------------------------------------------------
1 | interface HotCountParams {
2 | likeCount: number
3 | dislikeCount: number
4 | commentCount: number
5 | }
6 | export default (options: HotCountParams) => {
7 | const { likeCount, dislikeCount, commentCount } = options;
8 | return (likeCount - dislikeCount + commentCount * 0.4) * 10;
9 | };
10 |
--------------------------------------------------------------------------------
/src/utils/getKeyName.ts:
--------------------------------------------------------------------------------
1 | import fs from 'fs/promises';
2 | import path from 'path';
3 |
4 | export default async (folder: string, address: string) => {
5 | const ret = await fs.readdir(path.join(folder, 'keystore'));
6 | const signFilenames = ret.filter((item) => item.startsWith('sign_') && item !== 'sign_default');
7 | let keyName = '';
8 | for (const filename of signFilenames) {
9 | const content = await fs.readFile(path.join(folder, 'keystore', filename), 'utf8');
10 | if (content.includes(address.toLocaleLowerCase().replace('0x', ''))) {
11 | keyName = filename.replace('sign_', '');
12 | }
13 | }
14 | return keyName;
15 | };
16 |
--------------------------------------------------------------------------------
/src/utils/getTimestampFromBlockTime.ts:
--------------------------------------------------------------------------------
1 | export default (blockTime: number) => parseInt(`${blockTime / 1000000}`, 10);
2 |
--------------------------------------------------------------------------------
/src/utils/handleRumAppProtocol.ts:
--------------------------------------------------------------------------------
1 | import { Event, ipcRenderer } from 'electron';
2 | import qs from 'query-string';
3 | import { parse as parseUri } from 'uri-js';
4 | import { joinGroup } from 'standaloneModals/joinGroup';
5 |
6 | const actions: Record unknown> = {
7 | '/join-group': (params: any) => {
8 | const seed = params.seed;
9 | if (!seed) {
10 | return;
11 | }
12 | try {
13 | JSON.parse(seed);
14 | } catch (e) {
15 | return;
16 | }
17 | joinGroup(seed);
18 | },
19 | };
20 |
21 | export const handleRumAppProtocol = () => {
22 | const handler = (_e: Event, a: any) => {
23 | console.log(a);
24 | try {
25 | const uri = parseUri(a);
26 | const pathName = uri.path?.replace(/\/$/, '');
27 | if (!pathName) { return; }
28 | const query = uri.query ? qs.parse(uri.query) : null;
29 | actions[pathName]?.(query);
30 | } catch (e) {}
31 | };
32 | ipcRenderer.on('rum-app', handler);
33 | return () => {
34 | ipcRenderer.off('rum-app', handler);
35 | };
36 | };
37 |
--------------------------------------------------------------------------------
/src/utils/index.ts:
--------------------------------------------------------------------------------
1 | export * from './PollingTask';
2 | export * from './runLoading';
3 | export * from './lang';
4 | export { default as isV2Seed } from './isV2Seed';
5 | export { default as sleep } from './sleep';
6 | export { default as base64 } from './base64';
7 | export { default as ago } from './ago';
8 | export { replaceSeedAsButton } from './replaceSeedAsButton';
9 |
10 | export const notNullFilter = (v: T | undefined | null): v is T => v !== undefined && v !== null;
11 |
--------------------------------------------------------------------------------
/src/utils/inputFinanceAmount.ts:
--------------------------------------------------------------------------------
1 | export default (amount: string) => {
2 | if (amount === '') {
3 | return '';
4 | }
5 | const re = /^[0-9]+[.]?[0-9]{0,8}$/;
6 | if (re.test(amount)) {
7 | if (amount.includes('.')) {
8 | const [prefix, postfix] = amount.split('.');
9 | return `${parseInt(prefix, 10)}.${postfix}`;
10 | }
11 | return `${parseInt(amount, 10)}`;
12 | }
13 | return null;
14 | };
15 |
--------------------------------------------------------------------------------
/src/utils/inspect.ts:
--------------------------------------------------------------------------------
1 | import { ipcRenderer } from 'electron';
2 |
3 | export const loadInspect = () => {
4 | const keys = new Set();
5 |
6 | const handleKeyDown = (e: KeyboardEvent) => {
7 | keys.add(e.key.toLowerCase());
8 | check();
9 | };
10 | const handleKeyUp = (e: KeyboardEvent) => {
11 | keys.delete(e.key.toLowerCase());
12 | };
13 | const handleBlur = () => {
14 | keys.clear();
15 | };
16 | const check = () => {
17 | const conditions = [
18 | keys.size === 3,
19 | keys.has('control') || keys.has('command'),
20 | keys.has('shift'),
21 | keys.has('c'),
22 | ];
23 | if (conditions.every(Boolean)) {
24 | ipcRenderer.send('inspect-picker');
25 | }
26 | };
27 | window.addEventListener('keydown', handleKeyDown);
28 | window.addEventListener('keyup', handleKeyUp);
29 | window.addEventListener('blur', handleBlur);
30 |
31 | return () => {
32 | window.removeEventListener('keydown', handleKeyDown);
33 | window.removeEventListener('keyup', handleKeyUp);
34 | window.removeEventListener('blur', handleBlur);
35 | };
36 | };
37 |
--------------------------------------------------------------------------------
/src/utils/isV2Seed.ts:
--------------------------------------------------------------------------------
1 | export default (seed: string) => seed.startsWith('rum://seed');
2 |
--------------------------------------------------------------------------------
/src/utils/lang/index.ts:
--------------------------------------------------------------------------------
1 | import { i18n } from 'store/i18n';
2 | import * as cn from './cn';
3 | import * as en from './en';
4 |
5 | export const lang = i18n.createLangLoader({
6 | cn,
7 | en,
8 | });
9 |
--------------------------------------------------------------------------------
/src/utils/mainScrollView.ts:
--------------------------------------------------------------------------------
1 | export const className = 'main-scroll-element';
2 |
3 | export const scrollToTop = () => {
4 | try {
5 | document.querySelector('.main-scroll-element')!.scroll(0, 0);
6 | } catch (_) {}
7 | };
8 |
9 | export const scrollTop = () => {
10 | try {
11 | return document.querySelector('.main-scroll-element')!.scrollTop || 0;
12 | } catch (_) {}
13 | return 0;
14 | };
15 |
--------------------------------------------------------------------------------
/src/utils/mimeType.ts:
--------------------------------------------------------------------------------
1 | const map: any = {
2 | gif: 'image/gif',
3 | htm: 'text/html',
4 | html: 'text/html',
5 | jpg: 'image/jpeg',
6 | jpeg: 'image/jpeg',
7 | jpe: 'image/jpeg',
8 | js: 'application/x-javascript',
9 | pdf: 'application/pdf',
10 | png: 'image/png',
11 | md: 'text/markdown',
12 | json: 'application/json',
13 | };
14 |
15 | export default {
16 | getByExt: (ext: string) => map[ext] || '',
17 | getByFilename: (filename: string) => map[(filename as any).split('.').pop()] || '',
18 | };
19 |
--------------------------------------------------------------------------------
/src/utils/mixinOAuth.ts:
--------------------------------------------------------------------------------
1 | import { createHash, randomBytes } from 'node:crypto';
2 |
3 | export const client_id = 'ef7ba9a7-c0ac-46a7-8ce3-717be19caf9c';
4 |
5 | const scope = 'PROFILE:READ';
6 |
7 | export const getVerifierAndChanllege = () => {
8 | const key = randomBytes(32);
9 | const verifier = key.toString('base64url');
10 | const hash = createHash('sha256');
11 | hash.update(key);
12 | const challenge = hash.digest('base64url');
13 | return { verifier, challenge };
14 | };
15 |
16 | export const getOAuthUrl = (challenge: string) => `https://mixin-www.zeromesh.net/oauth/authorize?client_id=${client_id}&scope=${scope}&response_type=code&code_challenge=${challenge}`;
17 |
--------------------------------------------------------------------------------
/src/utils/quorum/request.ts:
--------------------------------------------------------------------------------
1 | import { ipcRenderer } from 'electron';
2 |
3 | let id = 0;
4 |
5 | const callbackQueueMap = new Map unknown>();
6 |
7 | export interface QuorumIPCRequest {
8 | action: string
9 | param?: any
10 | id: number
11 | }
12 |
13 | export interface QuorumIPCResult {
14 | id: number
15 | data: T
16 | error: string | null
17 | }
18 |
19 | export const sendRequest = (
20 | param: Pick>,
21 | ) => {
22 | id += 1;
23 | const requestId = id;
24 | let resolve: (v: unknown) => unknown = () => {};
25 | const promise = new Promise((rs) => {
26 | resolve = rs;
27 | });
28 | callbackQueueMap.set(requestId, resolve);
29 | const data: QuorumIPCRequest = {
30 | ...param,
31 | id: requestId,
32 | };
33 | ipcRenderer.send('quorum', data);
34 | return promise as Promise>;
35 | };
36 |
37 | export const initQuorum = () => {
38 | ipcRenderer.on('quorum', (_event, args) => {
39 | const id = args.id;
40 | if (!id) {
41 | return;
42 | }
43 |
44 | const callback = callbackQueueMap.get(id);
45 | if (!callback) {
46 | return;
47 | }
48 |
49 | callback(args);
50 | callbackQueueMap.delete(id);
51 | });
52 | };
53 |
--------------------------------------------------------------------------------
/src/utils/removeGroupData.ts:
--------------------------------------------------------------------------------
1 | import Dexie from 'dexie';
2 | import { find } from 'lodash';
3 | import Database from 'hooks/useDatabase/database';
4 |
5 | export default (dbs: Array, groupId: string) => {
6 | const dexiePromise: Array = [];
7 | dbs.forEach((db) => {
8 | db.tables.forEach((table) => {
9 | const index = find(table.schema.indexes, (item) => item.name === 'GroupId');
10 | if (index) {
11 | dexiePromise.push(table.where({
12 | GroupId: groupId,
13 | }).delete());
14 | }
15 | });
16 | });
17 | return Promise.all(dexiePromise);
18 | };
19 |
--------------------------------------------------------------------------------
/src/utils/runLoading.ts:
--------------------------------------------------------------------------------
1 | import { runInAction } from 'mobx';
2 |
3 | type SetLoading = (l: boolean) => unknown;
4 | type UnknownFunction = (...p: Array) => unknown;
5 | type RunLoading = (s: SetLoading, fn: T) => Promise>;
6 | /**
7 | * 立即执行异步函数 fn。
8 | * 执行前调用 setLoading(true)，执行完毕调用 setLoading(false)
9 | */
10 | export const runLoading: RunLoading = async (setLoading, fn) => {
11 | runInAction(() => setLoading(true));
12 | try {
13 | const result = await fn();
14 | return result as ReturnType;
15 | } finally {
16 | runInAction(() => setLoading(false));
17 | }
18 | };
19 |
--------------------------------------------------------------------------------
/src/utils/schema.ts:
--------------------------------------------------------------------------------
1 | const SCHEMA_PREFIX = 'rum://objects/';
2 |
3 | export default {
4 | getSchemaPrefix() {
5 | return SCHEMA_PREFIX;
6 | },
7 | };
8 |
--------------------------------------------------------------------------------
/src/utils/setClipboard.ts:
--------------------------------------------------------------------------------
1 | import { clipboard } from 'electron';
2 |
3 | export const setClipboard = (text: string) => {
4 | clipboard.writeText(text);
5 | };
6 |
--------------------------------------------------------------------------------
/src/utils/sleep.ts:
--------------------------------------------------------------------------------
1 | export default (duration: number) =>
2 | new Promise((resolve: any) => {
3 | setTimeout(() => {
4 | resolve();
5 | }, duration);
6 | });
7 |
--------------------------------------------------------------------------------
/src/utils/urlify.ts:
--------------------------------------------------------------------------------
1 | export default (text: string) => {
2 | if (!text) {
3 | return text;
4 | }
5 | const urlRegex = /(https?:\/\/[^\s]+)/g;
6 | return text.replace(urlRegex, '$1');
7 | };
8 |
--------------------------------------------------------------------------------
/tsconfig-test.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "./tsconfig.json",
3 | "compilerOptions": {
4 | "target": "ES2020",
5 | "module": "CommonJS",
6 | }
7 | }
8 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "target": "ES2020",
4 | "module": "ESNext",
5 | "lib": ["dom", "esnext"],
6 | "declaration": true,
7 | "declarationMap": true,
8 | "noEmit": true,
9 | "jsx": "preserve",
10 | "strict": true,
11 | "pretty": true,
12 | "sourceMap": true,
13 | /* Additional Checks */
14 | "skipLibCheck": true,
15 | "noUnusedLocals": true,
16 | "noUnusedParameters": true,
17 | "noImplicitReturns": true,
18 | "noFallthroughCasesInSwitch": true,
19 | /* Module Resolution Options */
20 | "moduleResolution": "node",
21 | "esModuleInterop": true,
22 | "allowSyntheticDefaultImports": true,
23 | "resolveJsonModule": true,
24 | "allowJs": true,
25 | "baseUrl": "src",
26 | "paths": {
27 | "assets/*": ["../assets/*"],
28 | "quorum_bin/*": ["../quorum_bin/*"]
29 | }
30 | },
31 | "include": [
32 | "src",
33 | "vite.config.ts"
34 | ],
35 | "exclude": [
36 | "test",
37 | "release",
38 | "src/main.prod.js",
39 | "src/renderer.prod.js",
40 | "src/dist",
41 | ".erb/dll"
42 | ]
43 | }
44 |
--------------------------------------------------------------------------------
21 |
34 | );
35 |
--------------------------------------------------------------------------------
/src/standaloneModals/index.ts:
--------------------------------------------------------------------------------
1 | export * from './joinGroup';
2 | export { about } from './about';
3 | export { changeFontSize } from './changeFontSize';
4 | export { createGroup } from './createGroup';
5 | export { default as editProfile } from './editProfile';
6 | export { exportKeyData } from './exportKeyData';
7 | export { default as getMixinUID } from './getMixinUID';
8 | export { groupInfo } from './groupInfo';
9 | export { importKeyData } from './importKeyData';
10 | export { default as inputPassword } from './inputPassword';
11 | export { languageSelect } from './languageSelect';
12 | export { manageGroup } from './manageGroup';
13 | export { migrate } from './migrate';
14 | export { myGroup } from './myGroup';
15 | export { default as openBetaFeaturesModal } from './openBetaFeaturesModal';
16 | export { default as openProducerModal } from './openProducerModal';
17 | export { shareGroup } from './shareGroup';
18 | export { default as useMixinPayment } from './useMixinPayment';
19 |
--------------------------------------------------------------------------------
/src/standaloneModals/joinGroup/index.tsx:
--------------------------------------------------------------------------------
1 | import { modalService } from '../modal';
2 | import { Props } from './JoinGroup';
3 |
4 | export const joinGroup = (seed?: Props['seed']) => {
5 | const item = modalService.createModal();
6 | item.addModal('joinGroup', {
7 | rs: () => setTimeout(item.destoryModal, 3000),
8 | seed,
9 | });
10 | };
11 |
--------------------------------------------------------------------------------
/src/standaloneModals/modal.ts:
--------------------------------------------------------------------------------
1 | import { action, observable } from 'mobx';
2 |
3 | const state = observable({
4 | id: 0,
5 | componentMap: new Map= i && 'bg-black',
25 | props.value < i && 'bg-white',
26 | )}
27 | />
28 | {props.total - 1 !== i && (
29 |
30 | )}
31 |
32 | ))}
33 |
17 |
53 | );
54 |
--------------------------------------------------------------------------------
/src/store/apiConfigHistory.ts:
--------------------------------------------------------------------------------
1 | import { v4 as uuidV4 } from 'uuid';
2 | import ElectronApiConfigHistoryStore from 'store/electronApiConfigHistoryStore';
3 |
4 | export interface IApiConfig {
5 | origin: string
6 | jwt: string
7 | }
8 |
9 | const store = ElectronApiConfigHistoryStore.getStore();
10 |
11 | export interface IApiConfigHistoryItem extends IApiConfig {
12 | id: string
13 | }
14 |
15 | export function createApiConfigHistoryStore() {
16 | const apiConfigHistoryKey = 'apiConfigHistoryV2';
17 |
18 | return {
19 | apiConfigHistory: (store?.get(apiConfigHistoryKey) || []) as IApiConfigHistoryItem[],
20 |
21 | add(apiConfig: IApiConfig) {
22 | const exist = this.apiConfigHistory.find((a) => a.origin === apiConfig.origin);
23 | if (exist) {
24 | return;
25 | }
26 | this.apiConfigHistory.push({
27 | id: uuidV4(),
28 | ...apiConfig,
29 | });
30 | store?.set(apiConfigHistoryKey, this.apiConfigHistory);
31 | },
32 |
33 | update(apiConfig: IApiConfig) {
34 | this.apiConfigHistory = this.apiConfigHistory.map((_a) => {
35 | if (_a.origin === apiConfig.origin) {
36 | return {
37 | ..._a,
38 | ...apiConfig,
39 | };
40 | }
41 | return _a;
42 | });
43 | store?.set(apiConfigHistoryKey, this.apiConfigHistory);
44 | },
45 |
46 | remove(id: string) {
47 | this.apiConfigHistory = this.apiConfigHistory.filter((apiConfig) => apiConfig.id !== id);
48 | store?.set(apiConfigHistoryKey, this.apiConfigHistory);
49 | },
50 | };
51 | }
52 |
--------------------------------------------------------------------------------
/src/store/betaFeature.ts:
--------------------------------------------------------------------------------
1 | import ElectronCurrentNodeStore from 'store/electronCurrentNodeStore';
2 |
3 | const STORE_KEY = 'betaFeatures';
4 |
5 | type Item = 'PAID_GROUP' | 'RUM_EXCHANGE';
6 |
7 | export function createBetaFeatureStore() {
8 | return {
9 | betaFeatures: [] as Item[],
10 |
11 | init() {
12 | this.betaFeatures = (ElectronCurrentNodeStore.getStore().get(STORE_KEY) || ['PAID_GROUP']) as Item[];
13 | },
14 |
15 | add(item: Item) {
16 | this.betaFeatures.push(item);
17 | ElectronCurrentNodeStore.getStore().set(STORE_KEY, this.betaFeatures);
18 | },
19 |
20 | remove(item: Item) {
21 | this.betaFeatures = this.betaFeatures.filter((_item) => _item !== item);
22 | ElectronCurrentNodeStore.getStore().set(STORE_KEY, this.betaFeatures);
23 | },
24 |
25 | toggle(item: Item) {
26 | if (this.betaFeatures.includes(item)) {
27 | this.remove(item);
28 | } else {
29 | this.add(item);
30 | }
31 | },
32 | };
33 | }
34 |
--------------------------------------------------------------------------------
/src/store/electronApiConfigHistoryStore.ts:
--------------------------------------------------------------------------------
1 | import { isProduction, isStaging } from 'utils/env';
2 | import Store from 'electron-store';
3 |
4 | const ELECTRON_API_CONFIG_HISTORY_STORE_NAME = (isProduction ? `${isStaging ? 'staging_' : ''}api_config_history` : 'dev_api_config_history') + '_v1';
5 |
6 | export default {
7 | store: new Store({
8 | name: ELECTRON_API_CONFIG_HISTORY_STORE_NAME,
9 | }),
10 |
11 | getStore() {
12 | return this.store;
13 | },
14 | };
15 |
--------------------------------------------------------------------------------
/src/store/electronCurrentNodeStore.ts:
--------------------------------------------------------------------------------
1 | import { isProduction, isStaging } from 'utils/env';
2 | import Store from 'electron-store';
3 | import { digestMessage } from 'utils/digestMessage';
4 |
5 | const ELECTRON_STORE_NAME_PREFIX = isProduction ? `${isStaging ? 'staging_' : ''}` : 'dev_';
6 |
7 | export default {
8 | store: null as Store | null,
9 |
10 | getStore() {
11 | if (!this.store) {
12 | throw new Error('store is used before inited');
13 | }
14 | return this.store;
15 | },
16 |
17 | init(nodePublickey: string) {
18 | const storeName = `${ELECTRON_STORE_NAME_PREFIX}${digestMessage(nodePublickey)}`;
19 |
20 | this.store = new Store({ name: storeName });
21 | },
22 | };
23 |
--------------------------------------------------------------------------------
/src/store/electronNodeStore.ts:
--------------------------------------------------------------------------------
1 | import { isProduction, isStaging } from 'utils/env';
2 | import Store from 'electron-store';
3 |
4 | const ELECTRON_NODE_STORE_NAME = (isProduction ? `${isStaging ? 'staging_' : ''}node` : 'dev_node') + '_v1';
5 |
6 | export default {
7 | store: new Store({
8 | name: ELECTRON_NODE_STORE_NAME,
9 | }),
10 |
11 | getStore() {
12 | return this.store;
13 | },
14 | };
15 |
--------------------------------------------------------------------------------
/src/store/font.ts:
--------------------------------------------------------------------------------
1 | export function createFontStore() {
2 | return {
3 | fontSize: localStorage.getItem('font-size') || '14' as string,
4 |
5 | setFontSize(value: string) {
6 | if (['12', '14', '16', '18'].includes(value)) {
7 | this.fontSize = value;
8 | localStorage.setItem('font-size', value);
9 | }
10 | },
11 | };
12 | }
13 |
--------------------------------------------------------------------------------
/src/store/i18n/index.ts:
--------------------------------------------------------------------------------
1 | import { ipcRenderer } from 'electron';
2 | import { action, observable } from 'mobx';
3 |
4 | const STORAGE_KEY = 'I18N_CURRENT_LANG';
5 |
6 | const allLang = ['cn', 'en'] as const;
7 |
8 | export type AllLanguages = typeof allLang[number];
9 | type LangData
22 | {
27 | props.onChange(e.target.value.trim().slice(0, 40));
28 | }}
29 | margin="none"
30 | variant="outlined"
31 | placeholder={props.placeholder || lang.search}
32 | />
33 |
39 |
52 |
34 |
38 |