chore: 🎨 format

packages/megalodon/package.json

@@ -5,7 +5,8 @@
   "typings": "./lib/src/index.d.ts",
   "scripts": {
     "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",
     "test": "NODE_ENV=test jest -u --maxWorkers=3"
   },

packages/megalodon/src/entities/account.ts

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

packages/megalodon/src/entities/activity.ts

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

packages/megalodon/src/entities/announcement.ts

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

packages/megalodon/src/entities/application.ts

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

packages/megalodon/src/entities/async_attachment.ts

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

packages/megalodon/src/entities/attachment.ts

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

packages/megalodon/src/entities/card.ts

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

packages/megalodon/src/entities/context.ts

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

packages/megalodon/src/entities/conversation.ts

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

packages/megalodon/src/entities/emoji.ts

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

packages/megalodon/src/entities/featured_tag.ts

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

packages/megalodon/src/entities/field.ts

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

packages/megalodon/src/entities/filter.ts

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

packages/megalodon/src/entities/history.ts

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

packages/megalodon/src/entities/identity_proof.ts

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

packages/megalodon/src/entities/instance.ts

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

packages/megalodon/src/entities/list.ts

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

packages/megalodon/src/entities/marker.ts

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

packages/megalodon/src/entities/mention.ts

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

packages/megalodon/src/entities/notification.ts

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

packages/megalodon/src/entities/poll.ts

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

packages/megalodon/src/entities/poll_option.ts

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

packages/megalodon/src/entities/preferences.ts

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

packages/megalodon/src/entities/push_subscription.ts

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

packages/megalodon/src/entities/reaction.ts

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

packages/megalodon/src/entities/relationship.ts

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

packages/megalodon/src/entities/report.ts

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

packages/megalodon/src/entities/results.ts

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

packages/megalodon/src/entities/scheduled_status.ts

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

packages/megalodon/src/entities/source.ts

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

packages/megalodon/src/entities/stats.ts

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

packages/megalodon/src/entities/status.ts

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

packages/megalodon/src/entities/status_edit.ts

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

packages/megalodon/src/entities/status_params.ts

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

packages/megalodon/src/entities/tag.ts

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

packages/megalodon/src/entities/token.ts

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

packages/megalodon/src/entities/urls.ts

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

packages/megalodon/src/misskey/entity.ts

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

packages/megalodon/src/misskey/notification.ts

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

packages/megalodon/src/misskey/web_socket.ts

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