e2net/iceshrimp-legacy
2
0
Fork 0
Code Issues Pull requests Packages Projects Releases Activity

chore: 🎨 format

Browse source
This commit is contained in:
ThatOneCalculator 2023-07-13 18:32:23 -07:00
parent 361873c6f4
commit 2e4c30e572
No known key found for this signature in database
GPG key ID: 8703CACD01000000
42 changed files with 1504 additions and 1386 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
packages/megalodon/package.json
View file

@ -5,7 +5,8 @@
"typings": "./lib/src/index.d.ts", "typings": "./lib/src/index.d.ts",
"scripts": { "scripts": {
"build": "tsc -p ./", "build": "tsc -p ./",
"lint": "eslint --ext .js,.ts src", "lint": "pnpm rome check --apply src/**/*.ts",
"format": "pnpm rome format --write src/**/*.ts",
"doc": "typedoc --out ../docs ./src", "doc": "typedoc --out ../docs ./src",
"test": "NODE_ENV=test jest -u --maxWorkers=3" "test": "NODE_ENV=test jest -u --maxWorkers=3"
}, },

44
packages/megalodon/src/entities/account.ts
View file

@ -2,26 +2,26 @@
/// <reference path="source.ts" /> /// <reference path="source.ts" />
/// <reference path="field.ts" /> /// <reference path="field.ts" />
namespace Entity { namespace Entity {
export type Account = { export type Account = {
id: string id: string;
username: string username: string;
acct: string acct: string;
display_name: string display_name: string;
locked: boolean locked: boolean;
created_at: string created_at: string;
followers_count: number followers_count: number;
following_count: number following_count: number;
statuses_count: number statuses_count: number;
note: string note: string;
url: string url: string;
avatar: string avatar: string;
avatar_static: string avatar_static: string;
header: string header: string;
header_static: string header_static: string;
emojis: Array<Emoji> emojis: Array<Emoji>;
moved: Account | null moved: Account | null;
fields: Array<Field> fields: Array<Field>;
bot: boolean | null bot: boolean | null;
source?: Source source?: Source;
} };
} }

12
packages/megalodon/src/entities/activity.ts
View file

@ -1,8 +1,8 @@
namespace Entity { namespace Entity {
export type Activity = { export type Activity = {
week: string week: string;
statuses: string statuses: string;
logins: string logins: string;
registrations: string registrations: string;
} };
} }

52
packages/megalodon/src/entities/announcement.ts
View file

@ -3,32 +3,32 @@
/// <reference path="reaction.ts" /> /// <reference path="reaction.ts" />
namespace Entity { namespace Entity {
export type Announcement = { export type Announcement = {
id: string id: string;
content: string content: string;
starts_at: string | null starts_at: string | null;
ends_at: string | null ends_at: string | null;
published: boolean published: boolean;
all_day: boolean all_day: boolean;
published_at: string published_at: string;
updated_at: string updated_at: string;
read?: boolean read?: boolean;
mentions: Array<AnnouncementAccount> mentions: Array<AnnouncementAccount>;
statuses: Array<AnnouncementStatus> statuses: Array<AnnouncementStatus>;
tags: Array<Tag> tags: Array<Tag>;
emojis: Array<Emoji> emojis: Array<Emoji>;
reactions: Array<Reaction> reactions: Array<Reaction>;
} };
export type AnnouncementAccount = { export type AnnouncementAccount = {
id: string id: string;
username: string username: string;
url: string url: string;
acct: string acct: string;
} };
export type AnnouncementStatus = { export type AnnouncementStatus = {
id: string id: string;
url: string url: string;
} };
} }

10
packages/megalodon/src/entities/application.ts
View file

@ -1,7 +1,7 @@
namespace Entity { namespace Entity {
export type Application = { export type Application = {
name: string name: string;
website?: string | null website?: string | null;
vapid_key?: string | null vapid_key?: string | null;
} };
} }

22
packages/megalodon/src/entities/async_attachment.ts
View file

@ -1,14 +1,14 @@
/// <reference path="attachment.ts" /> /// <reference path="attachment.ts" />
namespace Entity { namespace Entity {
export type AsyncAttachment = { export type AsyncAttachment = {
id: string id: string;
type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio' type: "unknown" | "image" | "gifv" | "video" | "audio";
url: string | null url: string | null;
remote_url: string | null remote_url: string | null;
preview_url: string preview_url: string;
text_url: string | null text_url: string | null;
meta: Meta | null meta: Meta | null;
description: string | null description: string | null;
blurhash: string | null blurhash: string | null;
} };
} }

84
packages/megalodon/src/entities/attachment.ts
View file

@ -1,49 +1,49 @@
namespace Entity { namespace Entity {
export type Sub = { export type Sub = {
// For Image, Gifv, and Video // For Image, Gifv, and Video
width?: number width?: number;
height?: number height?: number;
size?: string size?: string;
aspect?: number aspect?: number;
// For Gifv and Video // For Gifv and Video
frame_rate?: string frame_rate?: string;
// For Audio, Gifv, and Video // For Audio, Gifv, and Video
duration?: number duration?: number;
bitrate?: number bitrate?: number;
} };
export type Focus = { export type Focus = {
x: number x: number;
y: number y: number;
} };
export type Meta = { export type Meta = {
original?: Sub original?: Sub;
small?: Sub small?: Sub;
focus?: Focus focus?: Focus;
length?: string length?: string;
duration?: number duration?: number;
fps?: number fps?: number;
size?: string size?: string;
width?: number width?: number;
height?: number height?: number;
aspect?: number aspect?: number;
audio_encode?: string audio_encode?: string;
audio_bitrate?: string audio_bitrate?: string;
audio_channel?: string audio_channel?: string;
} };
export type Attachment = { export type Attachment = {
id: string id: string;
type: 'unknown' | 'image' | 'gifv' | 'video' | 'audio' type: "unknown" | "image" | "gifv" | "video" | "audio";
url: string url: string;
remote_url: string | null remote_url: string | null;
preview_url: string | null preview_url: string | null;
text_url: string | null text_url: string | null;
meta: Meta | null meta: Meta | null;
description: string | null description: string | null;
blurhash: string | null blurhash: string | null;
} };
} }

28
packages/megalodon/src/entities/card.ts
View file

@ -1,16 +1,16 @@
namespace Entity { namespace Entity {
export type Card = { export type Card = {
url: string url: string;
title: string title: string;
description: string description: string;
type: 'link' | 'photo' | 'video' | 'rich' type: "link" | "photo" | "video" | "rich";
image?: string image?: string;
author_name?: string author_name?: string;
author_url?: string author_url?: string;
provider_name?: string provider_name?: string;
provider_url?: string provider_url?: string;
html?: string html?: string;
width?: number width?: number;
height?: number height?: number;
} };
} }

8
packages/megalodon/src/entities/context.ts
View file

@ -1,8 +1,8 @@
/// <reference path="status.ts" /> /// <reference path="status.ts" />
namespace Entity { namespace Entity {
export type Context = { export type Context = {
ancestors: Array<Status> ancestors: Array<Status>;
descendants: Array<Status> descendants: Array<Status>;
} };
} }

12
packages/megalodon/src/entities/conversation.ts
View file

@ -2,10 +2,10 @@
/// <reference path="status.ts" /> /// <reference path="status.ts" />
namespace Entity { namespace Entity {
export type Conversation = { export type Conversation = {
id: string id: string;
accounts: Array<Account> accounts: Array<Account>;
last_status: Status | null last_status: Status | null;
unread: boolean unread: boolean;
} };
} }

14
packages/megalodon/src/entities/emoji.ts
View file

@ -1,9 +1,9 @@
namespace Entity { namespace Entity {
export type Emoji = { export type Emoji = {
shortcode: string shortcode: string;
static_url: string static_url: string;
url: string url: string;
visible_in_picker: boolean visible_in_picker: boolean;
category: string category: string;
} };
} }

12
packages/megalodon/src/entities/featured_tag.ts
View file

@ -1,8 +1,8 @@
namespace Entity { namespace Entity {
export type FeaturedTag = { export type FeaturedTag = {
id: string id: string;
name: string name: string;
statuses_count: number statuses_count: number;
last_status_at: string last_status_at: string;
} };
} }

10
packages/megalodon/src/entities/field.ts
View file

@ -1,7 +1,7 @@
namespace Entity { namespace Entity {
export type Field = { export type Field = {
name: string name: string;
value: string value: string;
verified_at: string | null verified_at: string | null;
} };
} }

18
packages/megalodon/src/entities/filter.ts
View file

@ -1,12 +1,12 @@
namespace Entity { namespace Entity {
export type Filter = { export type Filter = {
id: string id: string;
phrase: string phrase: string;
context: Array<FilterContext> context: Array<FilterContext>;
expires_at: string | null expires_at: string | null;
irreversible: boolean irreversible: boolean;
whole_word: boolean whole_word: boolean;
} };
export type FilterContext = string export type FilterContext = string;
} }

10
packages/megalodon/src/entities/history.ts
View file

@ -1,7 +1,7 @@
namespace Entity { namespace Entity {
export type History = { export type History = {
day: string day: string;
uses: number uses: number;
accounts: number accounts: number;
} };
} }

14
packages/megalodon/src/entities/identity_proof.ts
View file

@ -1,9 +1,9 @@
namespace Entity { namespace Entity {
export type IdentityProof = { export type IdentityProof = {
provider: string provider: string;
provider_username: string provider_username: string;
updated_at: string updated_at: string;
proof_url: string proof_url: string;
profile_url: string profile_url: string;
} };
} }

70
packages/megalodon/src/entities/instance.ts
View file

@ -3,39 +3,39 @@
/// <reference path="stats.ts" /> /// <reference path="stats.ts" />
namespace Entity { namespace Entity {
export type Instance = { export type Instance = {
uri: string uri: string;
title: string title: string;
description: string description: string;
email: string email: string;
version: string version: string;
thumbnail: string | null thumbnail: string | null;
urls: URLs urls: URLs;
stats: Stats stats: Stats;
languages: Array<string> languages: Array<string>;
contact_account: Account | null contact_account: Account | null;
max_toot_chars?: number max_toot_chars?: number;
registrations?: boolean registrations?: boolean;
configuration?: { configuration?: {
statuses: { statuses: {
max_characters: number max_characters: number;
max_media_attachments: number max_media_attachments: number;
characters_reserved_per_url: number characters_reserved_per_url: number;
} };
media_attachments: { media_attachments: {
supported_mime_types: Array<string> supported_mime_types: Array<string>;
image_size_limit: number image_size_limit: number;
image_matrix_limit: number image_matrix_limit: number;
video_size_limit: number video_size_limit: number;
video_frame_limit: number video_frame_limit: number;
video_matrix_limit: number video_matrix_limit: number;
} };
polls: { polls: {
max_options: number max_options: number;
max_characters_per_option: number max_characters_per_option: number;
min_expiration: number min_expiration: number;
max_expiration: number max_expiration: number;
} };
} };
} };
} }

8
packages/megalodon/src/entities/list.ts
View file

@ -1,6 +1,6 @@
namespace Entity { namespace Entity {
export type List = { export type List = {
id: string id: string;
title: string title: string;
} };
} }

26
packages/megalodon/src/entities/marker.ts
View file

@ -1,15 +1,15 @@
namespace Entity { namespace Entity {
export type Marker = { export type Marker = {
home?: { home?: {
last_read_id: string last_read_id: string;
version: number version: number;
updated_at: string updated_at: string;
} };
notifications?: { notifications?: {
last_read_id: string last_read_id: string;
version: number version: number;
updated_at: string updated_at: string;
unread_count?: number unread_count?: number;
} };
} };
} }

12
packages/megalodon/src/entities/mention.ts
View file

@ -1,8 +1,8 @@
namespace Entity { namespace Entity {
export type Mention = { export type Mention = {
id: string id: string;
username: string username: string;
url: string url: string;
acct: string acct: string;
} };
} }

18
packages/megalodon/src/entities/notification.ts
View file

@ -2,14 +2,14 @@
/// <reference path="status.ts" /> /// <reference path="status.ts" />
namespace Entity { namespace Entity {
export type Notification = { export type Notification = {
account: Account account: Account;
created_at: string created_at: string;
id: string id: string;
status?: Status status?: Status;
emoji?: string emoji?: string;
type: NotificationType type: NotificationType;
} };
export type NotificationType = string export type NotificationType = string;
} }

20
packages/megalodon/src/entities/poll.ts
View file

@ -1,14 +1,14 @@
/// <reference path="poll_option.ts" /> /// <reference path="poll_option.ts" />
namespace Entity { namespace Entity {
export type Poll = { export type Poll = {
id: string id: string;
expires_at: string | null expires_at: string | null;
expired: boolean expired: boolean;
multiple: boolean multiple: boolean;
votes_count: number votes_count: number;
options: Array<PollOption> options: Array<PollOption>;
voted: boolean voted: boolean;
own_votes: Array<number> own_votes: Array<number>;
} };
} }

8
packages/megalodon/src/entities/poll_option.ts
View file

@ -1,6 +1,6 @@
namespace Entity { namespace Entity {
export type PollOption = { export type PollOption = {
title: string title: string;
votes_count: number | null votes_count: number | null;
} };
} }

14
packages/megalodon/src/entities/preferences.ts
View file

@ -1,9 +1,9 @@
namespace Entity { namespace Entity {
export type Preferences = { export type Preferences = {
'posting:default:visibility': 'public' | 'unlisted' | 'private' | 'direct' "posting:default:visibility": "public" | "unlisted" | "private" | "direct";
'posting:default:sensitive': boolean "posting:default:sensitive": boolean;
'posting:default:language': string | null "posting:default:language": string | null;
'reading:expand:media': 'default' | 'show_all' | 'hide_all' "reading:expand:media": "default" | "show_all" | "hide_all";
'reading:expand:spoilers': boolean "reading:expand:spoilers": boolean;
} };
} }

26
packages/megalodon/src/entities/push_subscription.ts
View file

@ -1,16 +1,16 @@
namespace Entity { namespace Entity {
export type Alerts = { export type Alerts = {
follow: boolean follow: boolean;
favourite: boolean favourite: boolean;
mention: boolean mention: boolean;
reblog: boolean reblog: boolean;
poll: boolean poll: boolean;
} };
export type PushSubscription = { export type PushSubscription = {
id: string id: string;
endpoint: string endpoint: string;
server_key: string server_key: string;
alerts: Alerts alerts: Alerts;
} };
} }

14
packages/megalodon/src/entities/reaction.ts
View file

@ -1,11 +1,11 @@
/// <reference path="account.ts" /> /// <reference path="account.ts" />
namespace Entity { namespace Entity {
export type Reaction = { export type Reaction = {
count: number count: number;
me: boolean me: boolean;
name: string name: string;
url?: string url?: string;
accounts?: Array<Account> accounts?: Array<Account>;
} };
} }

30
packages/megalodon/src/entities/relationship.ts
View file

@ -1,17 +1,17 @@
namespace Entity { namespace Entity {
export type Relationship = { export type Relationship = {
id: string id: string;
following: boolean following: boolean;
followed_by: boolean followed_by: boolean;
delivery_following?: boolean delivery_following?: boolean;
blocking: boolean blocking: boolean;
blocked_by: boolean blocked_by: boolean;
muting: boolean muting: boolean;
muting_notifications: boolean muting_notifications: boolean;
requested: boolean requested: boolean;
domain_blocking: boolean domain_blocking: boolean;
showing_reblogs: boolean showing_reblogs: boolean;
endorsed: boolean endorsed: boolean;
notifying: boolean notifying: boolean;
} };
} }

14
packages/megalodon/src/entities/report.ts
View file

@ -1,9 +1,9 @@
namespace Entity { namespace Entity {
export type Report = { export type Report = {
id: string id: string;
action_taken: string action_taken: string;
comment: string comment: string;
account_id: string account_id: string;
status_ids: Array<string> status_ids: Array<string>;
} };
} }

10
packages/megalodon/src/entities/results.ts
View file

@ -3,9 +3,9 @@
/// <reference path="tag.ts" /> /// <reference path="tag.ts" />
namespace Entity { namespace Entity {
export type Results = { export type Results = {
accounts: Array<Account> accounts: Array<Account>;
statuses: Array<Status> statuses: Array<Status>;
hashtags: Array<Tag> hashtags: Array<Tag>;
} };
} }

12
packages/megalodon/src/entities/scheduled_status.ts
View file

@ -1,10 +1,10 @@
/// <reference path="attachment.ts" /> /// <reference path="attachment.ts" />
/// <reference path="status_params.ts" /> /// <reference path="status_params.ts" />
namespace Entity { namespace Entity {
export type ScheduledStatus = { export type ScheduledStatus = {
id: string id: string;
scheduled_at: string scheduled_at: string;
params: StatusParams params: StatusParams;
media_attachments: Array<Attachment> media_attachments: Array<Attachment>;
} };
} }

14
packages/megalodon/src/entities/source.ts
View file

@ -1,10 +1,10 @@
/// <reference path="field.ts" /> /// <reference path="field.ts" />
namespace Entity { namespace Entity {
export type Source = { export type Source = {
privacy: string | null privacy: string | null;
sensitive: boolean | null sensitive: boolean | null;
language: string | null language: string | null;
note: string note: string;
fields: Array<Field> fields: Array<Field>;
} };
} }

10
packages/megalodon/src/entities/stats.ts
View file

@ -1,7 +1,7 @@
namespace Entity { namespace Entity {
export type Stats = { export type Stats = {
user_count: number user_count: number;
status_count: number status_count: number;
domain_count: number domain_count: number;
} };
} }

66
packages/megalodon/src/entities/status.ts
View file

@ -9,37 +9,37 @@
/// <reference path="reaction.ts" /> /// <reference path="reaction.ts" />
namespace Entity { namespace Entity {
export type Status = { export type Status = {
id: string id: string;
uri: string uri: string;
url: string url: string;
account: Account account: Account;
in_reply_to_id: string | null in_reply_to_id: string | null;
in_reply_to_account_id: string | null in_reply_to_account_id: string | null;
reblog: Status | null reblog: Status | null;
content: string content: string;
plain_content: string | null plain_content: string | null;
created_at: string created_at: string;
emojis: Emoji[] emojis: Emoji[];
replies_count: number replies_count: number;
reblogs_count: number reblogs_count: number;
favourites_count: number favourites_count: number;
reblogged: boolean | null reblogged: boolean | null;
favourited: boolean | null favourited: boolean | null;
muted: boolean | null muted: boolean | null;
sensitive: boolean sensitive: boolean;
spoiler_text: string spoiler_text: string;
visibility: 'public' | 'unlisted' | 'private' | 'direct' visibility: "public" | "unlisted" | "private" | "direct";
media_attachments: Array<Attachment> media_attachments: Array<Attachment>;
mentions: Array<Mention> mentions: Array<Mention>;
tags: Array<Tag> tags: Array<Tag>;
card: Card | null card: Card | null;
poll: Poll | null poll: Poll | null;
application: Application | null application: Application | null;
language: string | null language: string | null;
pinned: boolean | null pinned: boolean | null;
emoji_reactions: Array<Reaction> emoji_reactions: Array<Reaction>;
quote: Status | null quote: Status | null;
bookmarked: boolean bookmarked: boolean;
} };
} }

22
packages/megalodon/src/entities/status_edit.ts
View file

@ -9,15 +9,15 @@
/// <reference path="reaction.ts" /> /// <reference path="reaction.ts" />
namespace Entity { namespace Entity {
export type StatusEdit = { export type StatusEdit = {
account: Account account: Account;
content: string content: string;
plain_content: string | null plain_content: string | null;
created_at: string created_at: string;
emojis: Emoji[] emojis: Emoji[];
sensitive: boolean sensitive: boolean;
spoiler_text: string spoiler_text: string;
media_attachments: Array<Attachment> media_attachments: Array<Attachment>;
poll: Poll | null poll: Poll | null;
} };
} }

20
packages/megalodon/src/entities/status_params.ts
View file

@ -1,12 +1,12 @@
namespace Entity { namespace Entity {
export type StatusParams = { export type StatusParams = {
text: string text: string;
in_reply_to_id: string | null in_reply_to_id: string | null;
media_ids: Array<string> | null media_ids: Array<string> | null;
sensitive: boolean | null sensitive: boolean | null;
spoiler_text: string | null spoiler_text: string | null;
visibility: 'public' | 'unlisted' | 'private' | 'direct' visibility: "public" | "unlisted" | "private" | "direct";
scheduled_at: string | null scheduled_at: string | null;
application_id: string application_id: string;
} };
} }

12
packages/megalodon/src/entities/tag.ts
View file

@ -1,10 +1,10 @@
/// <reference path="history.ts" /> /// <reference path="history.ts" />
namespace Entity { namespace Entity {
export type Tag = { export type Tag = {
name: string name: string;
url: string url: string;
history: Array<History> | null history: Array<History> | null;
following?: boolean following?: boolean;
} };
} }

12
packages/megalodon/src/entities/token.ts
View file

@ -1,8 +1,8 @@
namespace Entity { namespace Entity {
export type Token = { export type Token = {
access_token: string access_token: string;
token_type: string token_type: string;
scope: string scope: string;
created_at: number created_at: number;
} };
} }

6
packages/megalodon/src/entities/urls.ts
View file

@ -1,5 +1,5 @@
namespace Entity { namespace Entity {
export type URLs = { export type URLs = {
streaming_api: string streaming_api: string;
} };
} }

1263
packages/megalodon/src/misskey/api_client.ts
View file

File diff suppressed because it is too large Load diff

2
packages/megalodon/src/misskey/entity.ts
View file

@ -25,4 +25,4 @@
/// <reference path="entities/session.ts" /> /// <reference path="entities/session.ts" />
/// <reference path="entities/stats.ts" /> /// <reference path="entities/stats.ts" />
export default MisskeyEntity export default MisskeyEntity;

26
packages/megalodon/src/misskey/notification.ts
View file

@ -1,16 +1,18 @@
import MisskeyEntity from './entity' import MisskeyEntity from "./entity";
namespace MisskeyNotificationType { namespace MisskeyNotificationType {
export const Follow: MisskeyEntity.NotificationType = 'follow' export const Follow: MisskeyEntity.NotificationType = "follow";
export const Mention: MisskeyEntity.NotificationType = 'mention' export const Mention: MisskeyEntity.NotificationType = "mention";
export const Reply: MisskeyEntity.NotificationType = 'reply' export const Reply: MisskeyEntity.NotificationType = "reply";
export const Renote: MisskeyEntity.NotificationType = 'renote' export const Renote: MisskeyEntity.NotificationType = "renote";
export const Quote: MisskeyEntity.NotificationType = 'quote' export const Quote: MisskeyEntity.NotificationType = "quote";
export const Reaction: MisskeyEntity.NotificationType = 'favourite' export const Reaction: MisskeyEntity.NotificationType = "favourite";
export const PollEnded: MisskeyEntity.NotificationType = 'pollEnded' export const PollEnded: MisskeyEntity.NotificationType = "pollEnded";
export const ReceiveFollowRequest: MisskeyEntity.NotificationType = 'receiveFollowRequest' export const ReceiveFollowRequest: MisskeyEntity.NotificationType =
export const FollowRequestAccepted: MisskeyEntity.NotificationType = 'followRequestAccepted' "receiveFollowRequest";
export const GroupInvited: MisskeyEntity.NotificationType = 'groupInvited' export const FollowRequestAccepted: MisskeyEntity.NotificationType =
"followRequestAccepted";
export const GroupInvited: MisskeyEntity.NotificationType = "groupInvited";
} }
export default MisskeyNotificationType export default MisskeyNotificationType;

802
packages/megalodon/src/misskey/web_socket.ts
View file

@ -1,329 +1,365 @@
import WS from 'ws' import WS from "ws";
import dayjs, { Dayjs } from 'dayjs' import dayjs, { Dayjs } from "dayjs";
import { v4 as uuid } from 'uuid' import { v4 as uuid } from "uuid";
import { EventEmitter } from 'events' import { EventEmitter } from "events";
import { WebSocketInterface } from '../megalodon' import { WebSocketInterface } from "../megalodon";
import proxyAgent, { ProxyConfig } from '../proxy_config' import proxyAgent, { ProxyConfig } from "../proxy_config";
import MisskeyAPI from './api_client' import MisskeyAPI from "./api_client";
/** /**
* WebSocket * WebSocket
* Misskey is not support http streaming. It supports websocket instead of streaming. * Misskey is not support http streaming. It supports websocket instead of streaming.
* So this class connect to Misskey server with WebSocket. * So this class connect to Misskey server with WebSocket.
*/ */
export default class WebSocket extends EventEmitter implements WebSocketInterface { export default class WebSocket
public url: string extends EventEmitter
public channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list' implements WebSocketInterface
public parser: any {
public headers: { [key: string]: string } public url: string;
public proxyConfig: ProxyConfig | false = false public channel:
public listId: string | null = null | "user"
private _converter: MisskeyAPI.Converter | "localTimeline"
private _accessToken: string | "hybridTimeline"
private _reconnectInterval: number | "globalTimeline"
private _reconnectMaxAttempts: number | "conversation"
private _reconnectCurrentAttempts: number | "list";
private _connectionClosed: boolean public parser: any;
private _client: WS | null = null public headers: { [key: string]: string };
private _channelID: string public proxyConfig: ProxyConfig | false = false;
private _pongReceivedTimestamp: Dayjs public listId: string | null = null;
private _heartbeatInterval: number = 60000 private _converter: MisskeyAPI.Converter;
private _pongWaiting: boolean = false private _accessToken: string;
private _reconnectInterval: number;
private _reconnectMaxAttempts: number;
private _reconnectCurrentAttempts: number;
private _connectionClosed: boolean;
private _client: WS | null = null;
private _channelID: string;
private _pongReceivedTimestamp: Dayjs;
private _heartbeatInterval = 60000;
private _pongWaiting = false;
/** /**
* @param url Full url of websocket: e.g. wss://misskey.io/streaming * @param url Full url of websocket: e.g. wss://misskey.io/streaming
* @param channel Channel name is user, localTimeline, hybridTimeline, globalTimeline, conversation or list. * @param channel Channel name is user, localTimeline, hybridTimeline, globalTimeline, conversation or list.
* @param accessToken The access token. * @param accessToken The access token.
* @param listId This parameter is required when you specify list as channel. * @param listId This parameter is required when you specify list as channel.
*/ */
constructor( constructor(
url: string, url: string,
channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list', channel:
accessToken: string, | "user"
listId: string | undefined, | "localTimeline"
userAgent: string, | "hybridTimeline"
proxyConfig: ProxyConfig | false = false, | "globalTimeline"
converter: MisskeyAPI.Converter | "conversation"
) { | "list",
super() accessToken: string,
this.url = url listId: string | undefined,
this.parser = new Parser() userAgent: string,
this.channel = channel proxyConfig: ProxyConfig | false = false,
this.headers = { converter: MisskeyAPI.Converter,
'User-Agent': userAgent ) {
} super();
if (listId === undefined) { this.url = url;
this.listId = null this.parser = new Parser();
} else { this.channel = channel;
this.listId = listId this.headers = {
} "User-Agent": userAgent,
this.proxyConfig = proxyConfig };
this._accessToken = accessToken if (listId === undefined) {
this._reconnectInterval = 10000 this.listId = null;
this._reconnectMaxAttempts = Infinity } else {
this._reconnectCurrentAttempts = 0 this.listId = listId;
this._connectionClosed = false }
this._channelID = uuid() this.proxyConfig = proxyConfig;
this._pongReceivedTimestamp = dayjs() this._accessToken = accessToken;
this._converter = converter this._reconnectInterval = 10000;
} this._reconnectMaxAttempts = Infinity;
this._reconnectCurrentAttempts = 0;
this._connectionClosed = false;
this._channelID = uuid();
this._pongReceivedTimestamp = dayjs();
this._converter = converter;
}
/** /**
* Start websocket connection. * Start websocket connection.
*/ */
public start() { public start() {
this._connectionClosed = false this._connectionClosed = false;
this._resetRetryParams() this._resetRetryParams();
this._startWebSocketConnection() this._startWebSocketConnection();
} }
private baseUrlToHost(baseUrl: string): string { private baseUrlToHost(baseUrl: string): string {
return baseUrl.replace('https://', '') return baseUrl.replace("https://", "");
} }
/** /**
* Reset connection and start new websocket connection. * Reset connection and start new websocket connection.
*/ */
private _startWebSocketConnection() { private _startWebSocketConnection() {
this._resetConnection() this._resetConnection();
this._setupParser() this._setupParser();
this._client = this._connect() this._client = this._connect();
this._bindSocket(this._client) this._bindSocket(this._client);
} }
/** /**
* Stop current connection. * Stop current connection.
*/ */
public stop() { public stop() {
this._connectionClosed = true this._connectionClosed = true;
this._resetConnection() this._resetConnection();
this._resetRetryParams() this._resetRetryParams();
} }
/** /**
* Clean up current connection, and listeners. * Clean up current connection, and listeners.
*/ */
private _resetConnection() { private _resetConnection() {
if (this._client) { if (this._client) {
this._client.close(1000) this._client.close(1000);
this._client.removeAllListeners() this._client.removeAllListeners();
this._client = null this._client = null;
} }
if (this.parser) { if (this.parser) {
this.parser.removeAllListeners() this.parser.removeAllListeners();
} }
} }
/** /**
* Resets the parameters used in reconnect. * Resets the parameters used in reconnect.
*/ */
private _resetRetryParams() { private _resetRetryParams() {
this._reconnectCurrentAttempts = 0 this._reconnectCurrentAttempts = 0;
} }
/** /**
* Connect to the endpoint. * Connect to the endpoint.
*/ */
private _connect(): WS { private _connect(): WS {
let options: WS.ClientOptions = { let options: WS.ClientOptions = {
headers: this.headers headers: this.headers,
} };
if (this.proxyConfig) { if (this.proxyConfig) {
options = Object.assign(options, { options = Object.assign(options, {
agent: proxyAgent(this.proxyConfig) agent: proxyAgent(this.proxyConfig),
}) });
} }
const cli: WS = new WS(`${this.url}?i=${this._accessToken}`, options) const cli: WS = new WS(`${this.url}?i=${this._accessToken}`, options);
return cli return cli;
} }
/** /**
* Connect specified channels in websocket. * Connect specified channels in websocket.
*/ */
private _channel() { private _channel() {
if (!this._client) { if (!this._client) {
return return;
} }
switch (this.channel) { switch (this.channel) {
case 'conversation': case "conversation":
this._client.send( this._client.send(
JSON.stringify({ JSON.stringify({
type: 'connect', type: "connect",
body: { body: {
channel: 'main', channel: "main",
id: this._channelID id: this._channelID,
} },
}) }),
) );
break break;
case 'user': case "user":
this._client.send( this._client.send(
JSON.stringify({ JSON.stringify({
type: 'connect', type: "connect",
body: { body: {
channel: 'main', channel: "main",
id: this._channelID id: this._channelID,
} },
}) }),
) );
this._client.send( this._client.send(
JSON.stringify({ JSON.stringify({
type: 'connect', type: "connect",
body: { body: {
channel: 'homeTimeline', channel: "homeTimeline",
id: this._channelID id: this._channelID,
} },
}) }),
) );
break break;
case 'list': case "list":
this._client.send( this._client.send(
JSON.stringify({ JSON.stringify({
type: 'connect', type: "connect",
body: { body: {
channel: 'userList', channel: "userList",
id: this._channelID, id: this._channelID,
params: { params: {
listId: this.listId listId: this.listId,
} },
} },
}) }),
) );
break break;
default: default:
this._client.send( this._client.send(
JSON.stringify({ JSON.stringify({
type: 'connect', type: "connect",
body: { body: {
channel: this.channel, channel: this.channel,
id: this._channelID id: this._channelID,
} },
}) }),
) );
break break;
} }
} }
/** /**
* Reconnects to the same endpoint. * Reconnects to the same endpoint.
*/ */
private _reconnect() { private _reconnect() {
setTimeout(() => { setTimeout(() => {
// Skip reconnect when client is connecting. // Skip reconnect when client is connecting.
// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L365 // https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L365
if (this._client && this._client.readyState === WS.CONNECTING) { if (this._client && this._client.readyState === WS.CONNECTING) {
return return;
} }
if (this._reconnectCurrentAttempts < this._reconnectMaxAttempts) { if (this._reconnectCurrentAttempts < this._reconnectMaxAttempts) {
this._reconnectCurrentAttempts++ this._reconnectCurrentAttempts++;
this._clearBinding() this._clearBinding();
if (this._client) { if (this._client) {
// In reconnect, we want to close the connection immediately, // In reconnect, we want to close the connection immediately,
// because recoonect is necessary when some problems occur. // because recoonect is necessary when some problems occur.
this._client.terminate() this._client.terminate();
} }
// Call connect methods // Call connect methods
console.log('Reconnecting') console.log("Reconnecting");
this._client = this._connect() this._client = this._connect();
this._bindSocket(this._client) this._bindSocket(this._client);
} }
}, this._reconnectInterval) }, this._reconnectInterval);
} }
/** /**
* Clear binding event for websocket client. * Clear binding event for websocket client.
*/ */
private _clearBinding() { private _clearBinding() {
if (this._client) { if (this._client) {
this._client.removeAllListeners('close') this._client.removeAllListeners("close");
this._client.removeAllListeners('pong') this._client.removeAllListeners("pong");
this._client.removeAllListeners('open') this._client.removeAllListeners("open");
this._client.removeAllListeners('message') this._client.removeAllListeners("message");
this._client.removeAllListeners('error') this._client.removeAllListeners("error");
} }
} }
/** /**
* Bind event for web socket client. * Bind event for web socket client.
* @param client A WebSocket instance. * @param client A WebSocket instance.
*/ */
private _bindSocket(client: WS) { private _bindSocket(client: WS) {
client.on('close', (code: number, _reason: Buffer) => { client.on("close", (code: number, _reason: Buffer) => {
if (code === 1000) { if (code === 1000) {
this.emit('close', {}) this.emit("close", {});
} else { } else {
console.log(`Closed connection with ${code}`) console.log(`Closed connection with ${code}`);
if (!this._connectionClosed) { if (!this._connectionClosed) {
this._reconnect() this._reconnect();
} }
} }
}) });
client.on('pong', () => { client.on("pong", () => {
this._pongWaiting = false this._pongWaiting = false;
this.emit('pong', {}) this.emit("pong", {});
this._pongReceivedTimestamp = dayjs() this._pongReceivedTimestamp = dayjs();
// It is required to anonymous function since get this scope in checkAlive. // It is required to anonymous function since get this scope in checkAlive.
setTimeout(() => this._checkAlive(this._pongReceivedTimestamp), this._heartbeatInterval) setTimeout(
}) () => this._checkAlive(this._pongReceivedTimestamp),
client.on('open', () => { this._heartbeatInterval,
this.emit('connect', {}) );
this._channel() });
// Call first ping event. client.on("open", () => {
setTimeout(() => { this.emit("connect", {});
client.ping('') this._channel();
}, 10000) // Call first ping event.
}) setTimeout(() => {
client.on('message', (data: WS.Data, isBinary: boolean) => { client.ping("");
this.parser.parse(data, isBinary, this._channelID) }, 10000);
}) });
client.on('error', (err: Error) => { client.on("message", (data: WS.Data, isBinary: boolean) => {
this.emit('error', err) this.parser.parse(data, isBinary, this._channelID);
}) });
} client.on("error", (err: Error) => {
this.emit("error", err);
});
}
/** /**
* Set up parser when receive message. * Set up parser when receive message.
*/ */
private _setupParser() { private _setupParser() {
this.parser.on('update', (note: MisskeyAPI.Entity.Note) => { this.parser.on("update", (note: MisskeyAPI.Entity.Note) => {
this.emit('update', this._converter.note(note, this.baseUrlToHost(this.url))) this.emit(
}) "update",
this.parser.on('notification', (notification: MisskeyAPI.Entity.Notification) => { this._converter.note(note, this.baseUrlToHost(this.url)),
this.emit('notification', this._converter.notification(notification, this.baseUrlToHost(this.url))) );
}) });
this.parser.on('conversation', (note: MisskeyAPI.Entity.Note) => { this.parser.on(
this.emit('conversation', this._converter.noteToConversation(note, this.baseUrlToHost(this.url))) "notification",
}) (notification: MisskeyAPI.Entity.Notification) => {
this.parser.on('error', (err: Error) => { this.emit(
this.emit('parser-error', err) "notification",
}) this._converter.notification(
} notification,
this.baseUrlToHost(this.url),
),
);
},
);
this.parser.on("conversation", (note: MisskeyAPI.Entity.Note) => {
this.emit(
"conversation",
this._converter.noteToConversation(note, this.baseUrlToHost(this.url)),
);
});
this.parser.on("error", (err: Error) => {
this.emit("parser-error", err);
});
}
/** /**
* Call ping and wait to pong. * Call ping and wait to pong.
*/ */
private _checkAlive(timestamp: Dayjs) { private _checkAlive(timestamp: Dayjs) {
const now: Dayjs = dayjs() const now: Dayjs = dayjs();
// Block multiple calling, if multiple pong event occur. // Block multiple calling, if multiple pong event occur.
// It the duration is less than interval, through ping. // It the duration is less than interval, through ping.
if (now.diff(timestamp) > this._heartbeatInterval - 1000 && !this._connectionClosed) { if (
// Skip ping when client is connecting. now.diff(timestamp) > this._heartbeatInterval - 1000 &&
// https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L289 !this._connectionClosed
if (this._client && this._client.readyState !== WS.CONNECTING) { ) {
this._pongWaiting = true // Skip ping when client is connecting.
this._client.ping('') // https://github.com/websockets/ws/blob/7.2.1/lib/websocket.js#L289
setTimeout(() => { if (this._client && this._client.readyState !== WS.CONNECTING) {
if (this._pongWaiting) { this._pongWaiting = true;
this._pongWaiting = false this._client.ping("");
this._reconnect() setTimeout(() => {
} if (this._pongWaiting) {
}, 10000) this._pongWaiting = false;
} this._reconnect();
} }
} }, 10000);
}
}
}
} }
/** /**
@ -331,84 +367,92 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
* This class provides parser for websocket message. * This class provides parser for websocket message.
*/ */
export class Parser extends EventEmitter { export class Parser extends EventEmitter {
/** /**
* @param message Message body of websocket. * @param message Message body of websocket.
* @param channelID Parse only messages which has same channelID. * @param channelID Parse only messages which has same channelID.
*/ */
public parse(data: WS.Data, isBinary: boolean, channelID: string) { public parse(data: WS.Data, isBinary: boolean, channelID: string) {
const message = isBinary ? data : data.toString() const message = isBinary ? data : data.toString();
if (typeof message !== 'string') { if (typeof message !== "string") {
this.emit('heartbeat', {}) this.emit("heartbeat", {});
return return;
} }
if (message === '') { if (message === "") {
this.emit('heartbeat', {}) this.emit("heartbeat", {});
return return;
} }
let obj: { let obj: {
type: string type: string;
body: { body: {
id: string id: string;
type: string type: string;
body: any body: any;
} };
} };
let body: { let body: {
id: string id: string;
type: string type: string;
body: any body: any;
} };
try { try {
obj = JSON.parse(message) obj = JSON.parse(message);
if (obj.type !== 'channel') { if (obj.type !== "channel") {
return return;
} }
if (!obj.body) { if (!obj.body) {
return return;
} }
body = obj.body body = obj.body;
if (body.id !== channelID) { if (body.id !== channelID) {
return return;
} }
} catch (err) { } catch (err) {
this.emit('error', new Error(`Error parsing websocket reply: ${message}, error message: ${err}`)) this.emit(
return "error",
} new Error(
`Error parsing websocket reply: ${message}, error message: ${err}`,
),
);
return;
}
switch (body.type) { switch (body.type) {
case 'note': case "note":
this.emit('update', body.body as MisskeyAPI.Entity.Note) this.emit("update", body.body as MisskeyAPI.Entity.Note);
break break;
case 'notification': case "notification":
this.emit('notification', body.body as MisskeyAPI.Entity.Notification) this.emit("notification", body.body as MisskeyAPI.Entity.Notification);
break break;
case 'mention': { case "mention": {
const note = body.body as MisskeyAPI.Entity.Note const note = body.body as MisskeyAPI.Entity.Note;
if (note.visibility === 'specified') { if (note.visibility === "specified") {
this.emit('conversation', note) this.emit("conversation", note);
} }
break break;
} }
// When renote and followed event, the same notification will be received. // When renote and followed event, the same notification will be received.
case 'renote': case "renote":
case 'followed': case "followed":
case 'follow': case "follow":
case 'unfollow': case "unfollow":
case 'receiveFollowRequest': case "receiveFollowRequest":
case 'meUpdated': case "meUpdated":
case 'readAllNotifications': case "readAllNotifications":
case 'readAllUnreadSpecifiedNotes': case "readAllUnreadSpecifiedNotes":
case 'readAllAntennas': case "readAllAntennas":
case 'readAllUnreadMentions': case "readAllUnreadMentions":
case 'unreadNotification': case "unreadNotification":
// Ignore these events // Ignore these events
break break;
default: default:
this.emit('error', new Error(`Unknown event has received: ${JSON.stringify(body)}`)) this.emit(
break "error",
} new Error(`Unknown event has received: ${JSON.stringify(body)}`),
} );
break;
}
}
} }