upd: megalodon to v7

packages/megalodon/src/mastodon/api_client.ts

@@ -0,0 +1,661 @@
+import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
+import objectAssignDeep from 'object-assign-deep'
+
+import WebSocket from './web_socket'
+import Response from '../response'
+import { RequestCanceledError } from '../cancel'
+import proxyAgent, { ProxyConfig } from '../proxy_config'
+import { NO_REDIRECT, DEFAULT_SCOPE, DEFAULT_UA } from '../default'
+import MastodonEntity from './entity'
+import MegalodonEntity from '../entity'
+import NotificationType, { UnknownNotificationTypeError } from '../notification'
+import MastodonNotificationType from './notification'
+
+namespace MastodonAPI {
+  /**
+   * Interface
+   */
+  export interface Interface {
+    get<T = any>(path: string, params?: any, headers?: { [key: string]: string }, pathIsFullyQualified?: boolean): Promise<Response<T>>
+    put<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    putForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    patch<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    patchForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    post<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    postForm<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    del<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
+    cancel(): void
+    socket(path: string, stream: string, params?: string): WebSocket
+  }
+
+  /**
+   * Mastodon API client.
+   *
+   * Using axios for request, you will handle promises.
+   */
+  export class Client implements Interface {
+    static DEFAULT_SCOPE = DEFAULT_SCOPE
+    static DEFAULT_URL = 'https://mastodon.social'
+    static NO_REDIRECT = NO_REDIRECT
+
+    private accessToken: string | null
+    private baseUrl: string
+    private userAgent: string
+    private abortController: AbortController
+    private proxyConfig: ProxyConfig | false = false
+
+    /**
+     * @param baseUrl hostname or base URL
+     * @param accessToken access token from OAuth2 authorization
+     * @param userAgent UserAgent is specified in header on request.
+     * @param proxyConfig Proxy setting, or set false if don't use proxy.
+     */
+    constructor(
+      baseUrl: string,
+      accessToken: string | null = null,
+      userAgent: string = DEFAULT_UA,
+      proxyConfig: ProxyConfig | false = false
+    ) {
+      this.accessToken = accessToken
+      this.baseUrl = baseUrl
+      this.userAgent = userAgent
+      this.proxyConfig = proxyConfig
+      this.abortController = new AbortController()
+      axios.defaults.signal = this.abortController.signal
+    }
+
+    /**
+     * GET request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Query parameters
+     * @param headers Request header object
+     */
+    public async get<T>(
+      path: string,
+      params = {},
+      headers: { [key: string]: string } = {},
+      pathIsFullyQualified = false
+    ): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        params: params,
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .get<T>((pathIsFullyQualified ? '' : this.baseUrl) + path, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PUT request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async put<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .put<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PUT request to mastodon REST API for multipart.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async putForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .putForm<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PATCH request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async patch<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .patch<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * PATCH request to mastodon REST API for multipart.
+     * @param path relative path from baseUrl
+     * @param params Form data. If you want to post file, please use FormData()
+     * @param headers Request header object
+     */
+    public async patchForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .patchForm<T>(this.baseUrl + path, params, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse<T>) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * POST request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data
+     * @param headers Request header object
+     */
+    public async post<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios.post<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
+        const res: Response<T> = {
+          data: resp.data,
+          status: resp.status,
+          statusText: resp.statusText,
+          headers: resp.headers
+        }
+        return res
+      })
+    }
+
+    /**
+     * POST request to mastodon REST API for multipart.
+     * @param path relative path from baseUrl
+     * @param params Form data
+     * @param headers Request header object
+     */
+    public async postForm<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios.postForm<T>(this.baseUrl + path, params, options).then((resp: AxiosResponse<T>) => {
+        const res: Response<T> = {
+          data: resp.data,
+          status: resp.status,
+          statusText: resp.statusText,
+          headers: resp.headers
+        }
+        return res
+      })
+    }
+
+    /**
+     * DELETE request to mastodon REST API.
+     * @param path relative path from baseUrl
+     * @param params Form data
+     * @param headers Request header object
+     */
+    public async del<T>(path: string, params = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
+      let options: AxiosRequestConfig = {
+        data: params,
+        headers: headers,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      }
+      if (this.accessToken) {
+        options = objectAssignDeep({}, options, {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        })
+      }
+      if (this.proxyConfig) {
+        options = Object.assign(options, {
+          httpAgent: proxyAgent(this.proxyConfig),
+          httpsAgent: proxyAgent(this.proxyConfig)
+        })
+      }
+      return axios
+        .delete(this.baseUrl + path, options)
+        .catch((err: Error) => {
+          if (axios.isCancel(err)) {
+            throw new RequestCanceledError(err.message)
+          } else {
+            throw err
+          }
+        })
+        .then((resp: AxiosResponse) => {
+          const res: Response<T> = {
+            data: resp.data,
+            status: resp.status,
+            statusText: resp.statusText,
+            headers: resp.headers
+          }
+          return res
+        })
+    }
+
+    /**
+     * Cancel all requests in this instance.
+     * @returns void
+     */
+    public cancel(): void {
+      return this.abortController.abort()
+    }
+
+    /**
+     * Get connection and receive websocket connection for Pleroma API.
+     *
+     * @param path relative path from baseUrl: normally it is `/streaming`.
+     * @param stream Stream name, please refer: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/mastodon_api/mastodon_socket.ex#L19-28
+     * @returns WebSocket, which inherits from EventEmitter
+     */
+    public socket(path: string, stream: string, params?: string): WebSocket {
+      if (!this.accessToken) {
+        throw new Error('accessToken is required')
+      }
+      const url = this.baseUrl + path
+      const streaming = new WebSocket(url, stream, params, this.accessToken, this.userAgent, this.proxyConfig)
+      process.nextTick(() => {
+        streaming.start()
+      })
+      return streaming
+    }
+  }
+
+  export namespace Entity {
+    export type Account = MastodonEntity.Account
+    export type Activity = MastodonEntity.Activity
+    export type Announcement = MastodonEntity.Announcement
+    export type Application = MastodonEntity.Application
+    export type AsyncAttachment = MegalodonEntity.AsyncAttachment
+    export type Attachment = MastodonEntity.Attachment
+    export type Card = MastodonEntity.Card
+    export type Context = MastodonEntity.Context
+    export type Conversation = MastodonEntity.Conversation
+    export type Emoji = MastodonEntity.Emoji
+    export type FeaturedTag = MastodonEntity.FeaturedTag
+    export type Field = MastodonEntity.Field
+    export type Filter = MastodonEntity.Filter
+    export type History = MastodonEntity.History
+    export type IdentityProof = MastodonEntity.IdentityProof
+    export type Instance = MastodonEntity.Instance
+    export type List = MastodonEntity.List
+    export type Marker = MastodonEntity.Marker
+    export type Mention = MastodonEntity.Mention
+    export type Notification = MastodonEntity.Notification
+    export type Poll = MastodonEntity.Poll
+    export type PollOption = MastodonEntity.PollOption
+    export type Preferences = MastodonEntity.Preferences
+    export type PushSubscription = MastodonEntity.PushSubscription
+    export type Relationship = MastodonEntity.Relationship
+    export type Report = MastodonEntity.Report
+    export type Results = MastodonEntity.Results
+    export type Role = MastodonEntity.Role
+    export type ScheduledStatus = MastodonEntity.ScheduledStatus
+    export type Source = MastodonEntity.Source
+    export type Stats = MastodonEntity.Stats
+    export type Status = MastodonEntity.Status
+    export type StatusParams = MastodonEntity.StatusParams
+    export type StatusSource = MastodonEntity.StatusSource
+    export type Tag = MastodonEntity.Tag
+    export type Token = MastodonEntity.Token
+    export type URLs = MastodonEntity.URLs
+  }
+
+  export namespace Converter {
+    export const encodeNotificationType = (
+      t: MegalodonEntity.NotificationType
+    ): MastodonEntity.NotificationType | UnknownNotificationTypeError => {
+      switch (t) {
+        case NotificationType.Follow:
+          return MastodonNotificationType.Follow
+        case NotificationType.Favourite:
+          return MastodonNotificationType.Favourite
+        case NotificationType.Reblog:
+          return MastodonNotificationType.Reblog
+        case NotificationType.Mention:
+          return MastodonNotificationType.Mention
+        case NotificationType.FollowRequest:
+          return MastodonNotificationType.FollowRequest
+        case NotificationType.Status:
+          return MastodonNotificationType.Status
+        case NotificationType.PollExpired:
+          return MastodonNotificationType.Poll
+        case NotificationType.Update:
+          return MastodonNotificationType.Update
+        case NotificationType.AdminSignup:
+          return MastodonNotificationType.AdminSignup
+        case NotificationType.AdminReport:
+          return MastodonNotificationType.AdminReport
+        default:
+          return new UnknownNotificationTypeError()
+      }
+    }
+
+    export const decodeNotificationType = (
+      t: MastodonEntity.NotificationType
+    ): MegalodonEntity.NotificationType | UnknownNotificationTypeError => {
+      switch (t) {
+        case MastodonNotificationType.Follow:
+          return NotificationType.Follow
+        case MastodonNotificationType.Favourite:
+          return NotificationType.Favourite
+        case MastodonNotificationType.Mention:
+          return NotificationType.Mention
+        case MastodonNotificationType.Reblog:
+          return NotificationType.Reblog
+        case MastodonNotificationType.FollowRequest:
+          return NotificationType.FollowRequest
+        case MastodonNotificationType.Status:
+          return NotificationType.Status
+        case MastodonNotificationType.Poll:
+          return NotificationType.PollExpired
+        case MastodonNotificationType.Update:
+          return NotificationType.Update
+        case MastodonNotificationType.AdminSignup:
+          return NotificationType.AdminSignup
+        case MastodonNotificationType.AdminReport:
+          return NotificationType.AdminReport
+        default:
+          return new UnknownNotificationTypeError()
+      }
+    }
+
+    export const account = (a: Entity.Account): MegalodonEntity.Account => a
+    export const activity = (a: Entity.Activity): MegalodonEntity.Activity => a
+    export const announcement = (a: Entity.Announcement): MegalodonEntity.Announcement => a
+    export const application = (a: Entity.Application): MegalodonEntity.Application => a
+    export const attachment = (a: Entity.Attachment): MegalodonEntity.Attachment => a
+    export const async_attachment = (a: Entity.AsyncAttachment) => {
+      if (a.url) {
+        return {
+          id: a.id,
+          type: a.type,
+          url: a.url!,
+          remote_url: a.remote_url,
+          preview_url: a.preview_url,
+          text_url: a.text_url,
+          meta: a.meta,
+          description: a.description,
+          blurhash: a.blurhash
+        } as MegalodonEntity.Attachment
+      } else {
+        return a as MegalodonEntity.AsyncAttachment
+      }
+    }
+    export const card = (c: Entity.Card): MegalodonEntity.Card => c
+    export const context = (c: Entity.Context): MegalodonEntity.Context => ({
+      ancestors: Array.isArray(c.ancestors) ? c.ancestors.map(a => status(a)) : [],
+      descendants: Array.isArray(c.descendants) ? c.descendants.map(d => status(d)) : []
+    })
+    export const conversation = (c: Entity.Conversation): MegalodonEntity.Conversation => ({
+      id: c.id,
+      accounts: Array.isArray(c.accounts) ? c.accounts.map(a => account(a)) : [],
+      last_status: c.last_status ? status(c.last_status) : null,
+      unread: c.unread
+    })
+    export const emoji = (e: Entity.Emoji): MegalodonEntity.Emoji => e
+    export const featured_tag = (e: Entity.FeaturedTag): MegalodonEntity.FeaturedTag => e
+    export const field = (f: Entity.Field): MegalodonEntity.Field => f
+    export const filter = (f: Entity.Filter): MegalodonEntity.Filter => f
+    export const history = (h: Entity.History): MegalodonEntity.History => h
+    export const identity_proof = (i: Entity.IdentityProof): MegalodonEntity.IdentityProof => i
+    export const instance = (i: Entity.Instance): MegalodonEntity.Instance => i
+    export const list = (l: Entity.List): MegalodonEntity.List => l
+    export const marker = (m: Entity.Marker | Record<never, never>): MegalodonEntity.Marker | Record<never, never> => m
+    export const mention = (m: Entity.Mention): MegalodonEntity.Mention => m
+    export const notification = (n: Entity.Notification): MegalodonEntity.Notification | UnknownNotificationTypeError => {
+      const notificationType = decodeNotificationType(n.type)
+      if (notificationType instanceof UnknownNotificationTypeError) return notificationType
+      if (n.status) {
+        return {
+          account: account(n.account),
+          created_at: n.created_at,
+          id: n.id,
+          status: status(n.status),
+          type: notificationType
+        }
+      } else {
+        return {
+          account: account(n.account),
+          created_at: n.created_at,
+          id: n.id,
+          type: notificationType
+        }
+      }
+    }
+    export const poll = (p: Entity.Poll): MegalodonEntity.Poll => p
+    export const poll_option = (p: Entity.PollOption): MegalodonEntity.PollOption => p
+    export const preferences = (p: Entity.Preferences): MegalodonEntity.Preferences => p
+    export const push_subscription = (p: Entity.PushSubscription): MegalodonEntity.PushSubscription => p
+    export const relationship = (r: Entity.Relationship): MegalodonEntity.Relationship => r
+    export const report = (r: Entity.Report): MegalodonEntity.Report => r
+    export const results = (r: Entity.Results): MegalodonEntity.Results => ({
+      accounts: Array.isArray(r.accounts) ? r.accounts.map(a => account(a)) : [],
+      statuses: Array.isArray(r.statuses) ? r.statuses.map(s => status(s)) : [],
+      hashtags: Array.isArray(r.hashtags) ? r.hashtags.map(h => tag(h)) : []
+    })
+    export const scheduled_status = (s: Entity.ScheduledStatus): MegalodonEntity.ScheduledStatus => s
+    export const source = (s: Entity.Source): MegalodonEntity.Source => s
+    export const stats = (s: Entity.Stats): MegalodonEntity.Stats => s
+    export const status = (s: Entity.Status): MegalodonEntity.Status => ({
+      id: s.id,
+      uri: s.uri,
+      url: s.url,
+      account: account(s.account),
+      in_reply_to_id: s.in_reply_to_id,
+      in_reply_to_account_id: s.in_reply_to_account_id,
+      reblog: s.reblog ? status(s.reblog) : s.quote ? status(s.quote) : null,
+      content: s.content,
+      plain_content: null,
+      created_at: s.created_at,
+      emojis: Array.isArray(s.emojis) ? s.emojis.map(e => emoji(e)) : [],
+      replies_count: s.replies_count,
+      reblogs_count: s.reblogs_count,
+      favourites_count: s.favourites_count,
+      reblogged: s.reblogged,
+      favourited: s.favourited,
+      muted: s.muted,
+      sensitive: s.sensitive,
+      spoiler_text: s.spoiler_text,
+      visibility: s.visibility,
+      media_attachments: Array.isArray(s.media_attachments) ? s.media_attachments.map(m => attachment(m)) : [],
+      mentions: Array.isArray(s.mentions) ? s.mentions.map(m => mention(m)) : [],
+      tags: s.tags,
+      card: s.card ? card(s.card) : null,
+      poll: s.poll ? poll(s.poll) : null,
+      application: s.application ? application(s.application) : null,
+      language: s.language,
+      pinned: s.pinned,
+      emoji_reactions: [],
+      bookmarked: s.bookmarked ? s.bookmarked : false,
+      // Now quote is supported only fedibird.com.
+      quote: s.quote !== undefined && s.quote !== null
+    })
+    export const status_params = (s: Entity.StatusParams): MegalodonEntity.StatusParams => s
+    export const status_source = (s: Entity.StatusSource): MegalodonEntity.StatusSource => s
+    export const tag = (t: Entity.Tag): MegalodonEntity.Tag => t
+    export const token = (t: Entity.Token): MegalodonEntity.Token => t
+    export const urls = (u: Entity.URLs): MegalodonEntity.URLs => u
+  }
+}
+export default MastodonAPI

packages/megalodon/src/mastodon/entities/account.ts

@@ -0,0 +1,35 @@
+/// <reference path="emoji.ts" />
+/// <reference path="source.ts" />
+/// <reference path="field.ts" />
+/// <reference path="role.ts" />
+namespace MastodonEntity {
+  export type Account = {
+    id: string
+    username: string
+    acct: string
+    display_name: string
+    locked: boolean
+    discoverable?: boolean
+    group: boolean | null
+    noindex: boolean | null
+    suspended: boolean | null
+    limited: boolean | null
+    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
+    source?: Source
+    role?: Role
+    mute_expires_at?: string
+  }
+}

packages/megalodon/src/mastodon/entities/activity.ts

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

packages/megalodon/src/mastodon/entities/announcement.ts

@@ -0,0 +1,40 @@
+/// <reference path="emoji.ts" />
+
+namespace MastodonEntity {
+  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 | null
+    mentions: Array<AnnouncementAccount>
+    statuses: Array<AnnouncementStatus>
+    tags: Array<StatusTag>
+    emojis: Array<Emoji>
+    reactions: Array<AnnouncementReaction>
+  }
+
+  export type AnnouncementAccount = {
+    id: string
+    username: string
+    url: string
+    acct: string
+  }
+
+  export type AnnouncementStatus = {
+    id: string
+    url: string
+  }
+
+  export type AnnouncementReaction = {
+    name: string
+    count: number
+    me: boolean | null
+    url: string | null
+    static_url: string | null
+  }
+}

packages/megalodon/src/mastodon/entities/application.ts

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

packages/megalodon/src/mastodon/entities/async_attachment.ts

@@ -0,0 +1,14 @@
+/// <reference path="attachment.ts" />
+namespace MastodonEntity {
+  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/mastodon/entities/attachment.ts

@@ -0,0 +1,49 @@
+namespace MastodonEntity {
+  export type Sub = {
+    // For Image, Gifv, and Video
+    width?: number
+    height?: number
+    size?: string
+    aspect?: number
+
+    // For Gifv and Video
+    frame_rate?: string
+
+    // For Audio, Gifv, and Video
+    duration?: number
+    bitrate?: 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 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/mastodon/entities/card.ts

@@ -0,0 +1,18 @@
+namespace MastodonEntity {
+  export type Card = {
+    url: string
+    title: string
+    description: string
+    type: 'link' | 'photo' | 'video' | 'rich'
+    image: string | null
+    author_name: string
+    author_url: string
+    provider_name: string
+    provider_url: string
+    html: string
+    width: number
+    height: number
+    embed_url: string
+    blurhash: string | null
+  }
+}

packages/megalodon/src/mastodon/entities/context.ts

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

packages/megalodon/src/mastodon/entities/conversation.ts

@@ -0,0 +1,11 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+
+namespace MastodonEntity {
+  export type Conversation = {
+    id: string
+    accounts: Array<Account>
+    last_status: Status | null
+    unread: boolean
+  }
+}

packages/megalodon/src/mastodon/entities/emoji.ts

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

packages/megalodon/src/mastodon/entities/featured_tag.ts

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

packages/megalodon/src/mastodon/entities/field.ts

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

packages/megalodon/src/mastodon/entities/filter.ts

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

packages/megalodon/src/mastodon/entities/history.ts

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

packages/megalodon/src/mastodon/entities/identity_proof.ts

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

packages/megalodon/src/mastodon/entities/instance.ts

@@ -0,0 +1,49 @@
+/// <reference path="account.ts" />
+/// <reference path="urls.ts" />
+/// <reference path="stats.ts" />
+
+namespace MastodonEntity {
+  export type Instance = {
+    uri: string
+    title: string
+    description: string
+    email: string
+    version: string
+    thumbnail: string | null
+    urls: URLs
+    stats: Stats
+    languages: Array<string>
+    registrations: boolean
+    approval_required: boolean
+    invites_enabled: boolean
+    max_toot_chars?: number
+    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
+      }
+    }
+    contact_account: Account
+    rules: Array<InstanceRule>
+  }
+
+  export type InstanceRule = {
+    id: string
+    text: string
+  }
+}

packages/megalodon/src/mastodon/entities/list.ts

@@ -0,0 +1,9 @@
+namespace MastodonEntity {
+  export type List = {
+    id: string
+    title: string
+    replies_policy: RepliesPolicy
+  }
+
+  export type RepliesPolicy = 'followed' | 'list' | 'none'
+}

packages/megalodon/src/mastodon/entities/marker.ts

@@ -0,0 +1,14 @@
+namespace MastodonEntity {
+  export type Marker = {
+    home: {
+      last_read_id: string
+      version: number
+      updated_at: string
+    }
+    notifications: {
+      last_read_id: string
+      version: number
+      updated_at: string
+    }
+  }
+}

packages/megalodon/src/mastodon/entities/mention.ts

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

packages/megalodon/src/mastodon/entities/notification.ts

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

packages/megalodon/src/mastodon/entities/poll.ts

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

packages/megalodon/src/mastodon/entities/poll_option.ts

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

packages/megalodon/src/mastodon/entities/preferences.ts

@@ -0,0 +1,9 @@
+namespace MastodonEntity {
+  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/mastodon/entities/push_subscription.ts

@@ -0,0 +1,16 @@
+namespace MastodonEntity {
+  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
+  }
+}

packages/megalodon/src/mastodon/entities/relationship.ts

@@ -0,0 +1,18 @@
+namespace MastodonEntity {
+  export type Relationship = {
+    id: string
+    following: boolean
+    followed_by: boolean
+    blocking: boolean
+    blocked_by: boolean
+    muting: boolean
+    muting_notifications: boolean
+    requested: boolean
+    domain_blocking: boolean
+    showing_reblogs: boolean
+    endorsed: boolean
+    notifying: boolean
+    note: string
+    languages: Array<string>
+  }
+}

packages/megalodon/src/mastodon/entities/report.ts

@@ -0,0 +1,17 @@
+/// <reference path="account.ts" />
+
+namespace MastodonEntity {
+  export type Report = {
+    id: string
+    action_taken: boolean
+    action_taken_at: string | null
+    category: Category
+    comment: string
+    forwarded: boolean
+    status_ids: Array<string> | null
+    rule_ids: Array<string> | null
+    target_account: Account
+  }
+
+  export type Category = 'spam' | 'violation' | 'other'
+}

packages/megalodon/src/mastodon/entities/results.ts

@@ -0,0 +1,11 @@
+/// <reference path="account.ts" />
+/// <reference path="status.ts" />
+/// <reference path="tag.ts" />
+
+namespace MastodonEntity {
+  export type Results = {
+    accounts: Array<Account>
+    statuses: Array<Status>
+    hashtags: Array<Tag>
+  }
+}

packages/megalodon/src/mastodon/entities/role.ts

@@ -0,0 +1,5 @@
+namespace MastodonEntity {
+  export type Role = {
+    name: string
+  }
+}

packages/megalodon/src/mastodon/entities/scheduled_status.ts

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

packages/megalodon/src/mastodon/entities/source.ts

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

packages/megalodon/src/mastodon/entities/stats.ts

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

packages/megalodon/src/mastodon/entities/status.ts

@@ -0,0 +1,49 @@
+/// <reference path="account.ts" />
+/// <reference path="application.ts" />
+/// <reference path="mention.ts" />
+/// <reference path="tag.ts" />
+/// <reference path="attachment.ts" />
+/// <reference path="emoji.ts" />
+/// <reference path="card.ts" />
+/// <reference path="poll.ts" />
+
+namespace MastodonEntity {
+  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
+    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<StatusTag>
+    card: Card | null
+    poll: Poll | null
+    application: Application | null
+    language: string | null
+    pinned: boolean | null
+    bookmarked?: boolean
+    // These parameters are unique parameters in fedibird.com for quote.
+    quote_id?: string
+    quote?: Status | null
+  }
+
+  export type StatusTag = {
+    name: string
+    url: string
+  }
+}

packages/megalodon/src/mastodon/entities/status_params.ts

@@ -0,0 +1,12 @@
+namespace MastodonEntity {
+  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' | null
+    scheduled_at: string | null
+    application_id: number
+  }
+}

packages/megalodon/src/mastodon/entities/status_source.ts

@@ -0,0 +1,7 @@
+namespace MastodonEntity {
+  export type StatusSource = {
+    id: string
+    text: string
+    spoiler_text: string
+  }
+}

packages/megalodon/src/mastodon/entities/tag.ts

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

packages/megalodon/src/mastodon/entities/token.ts

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

packages/megalodon/src/mastodon/entities/urls.ts

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

packages/megalodon/src/mastodon/entity.ts

@@ -0,0 +1,39 @@
+/// <reference path="./entities/account.ts" />
+/// <reference path="./entities/activity.ts" />
+/// <reference path="./entities/announcement.ts" />
+/// <reference path="./entities/application.ts" />
+/// <reference path="./entities/async_attachment.ts" />
+/// <reference path="./entities/attachment.ts" />
+/// <reference path="./entities/card.ts" />
+/// <reference path="./entities/context.ts" />
+/// <reference path="./entities/conversation.ts" />
+/// <reference path="./entities/emoji.ts" />
+/// <reference path="./entities/featured_tag.ts" />
+/// <reference path="./entities/field.ts" />
+/// <reference path="./entities/filter.ts" />
+/// <reference path="./entities/history.ts" />
+/// <reference path="./entities/identity_proof.ts" />
+/// <reference path="./entities/instance.ts" />
+/// <reference path="./entities/list.ts" />
+/// <reference path="./entities/marker.ts" />
+/// <reference path="./entities/mention.ts" />
+/// <reference path="./entities/notification.ts" />
+/// <reference path="./entities/poll.ts" />
+/// <reference path="./entities/poll_option.ts" />
+/// <reference path="./entities/preferences.ts" />
+/// <reference path="./entities/push_subscription.ts" />
+/// <reference path="./entities/relationship.ts" />
+/// <reference path="./entities/report.ts" />
+/// <reference path="./entities/results.ts" />
+/// <reference path="./entities/role.ts" />
+/// <reference path="./entities/scheduled_status.ts" />
+/// <reference path="./entities/source.ts" />
+/// <reference path="./entities/stats.ts" />
+/// <reference path="./entities/status.ts" />
+/// <reference path="./entities/status_params.ts" />
+/// <reference path="./entities/status_source.ts" />
+/// <reference path="./entities/tag.ts" />
+/// <reference path="./entities/token.ts" />
+/// <reference path="./entities/urls.ts" />
+
+export default MastodonEntity

packages/megalodon/src/mastodon/notification.ts

@@ -0,0 +1,16 @@
+import MastodonEntity from './entity'
+
+namespace MastodonNotificationType {
+  export const Mention: MastodonEntity.NotificationType = 'mention'
+  export const Reblog: MastodonEntity.NotificationType = 'reblog'
+  export const Favourite: MastodonEntity.NotificationType = 'favourite'
+  export const Follow: MastodonEntity.NotificationType = 'follow'
+  export const Poll: MastodonEntity.NotificationType = 'poll'
+  export const FollowRequest: MastodonEntity.NotificationType = 'follow_request'
+  export const Status: MastodonEntity.NotificationType = 'status'
+  export const Update: MastodonEntity.NotificationType = 'update'
+  export const AdminSignup: MastodonEntity.NotificationType = 'admin.sign_up'
+  export const AdminReport: MastodonEntity.NotificationType = 'admin.report'
+}
+
+export default MastodonNotificationType

packages/megalodon/src/mastodon/web_socket.ts

@@ -0,0 +1,348 @@
+import WS from 'ws'
+import dayjs, { Dayjs } from 'dayjs'
+import { EventEmitter } from 'events'
+import proxyAgent, { ProxyConfig } from '../proxy_config'
+import { WebSocketInterface } from '../megalodon'
+import MastodonAPI from './api_client'
+import { UnknownNotificationTypeError } from '../notification'
+
+/**
+ * WebSocket
+ * Pleroma is not support streaming. It is support websocket instead of streaming.
+ * So this class connect to Phoenix websocket for Pleroma.
+ */
+export default class WebSocket extends EventEmitter implements WebSocketInterface {
+  public url: string
+  public stream: string
+  public params: string | null
+  public parser: Parser
+  public headers: { [key: string]: string }
+  public proxyConfig: ProxyConfig | false = false
+  private _accessToken: string
+  private _reconnectInterval: number
+  private _reconnectMaxAttempts: number
+  private _reconnectCurrentAttempts: number
+  private _connectionClosed: boolean
+  private _client: WS | null
+  private _pongReceivedTimestamp: Dayjs
+  private _heartbeatInterval: number = 60000
+  private _pongWaiting: boolean = false
+
+  /**
+   * @param url Full url of websocket: e.g. https://pleroma.io/api/v1/streaming
+   * @param stream Stream name, please refer: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/mastodon_api/mastodon_socket.ex#L19-28
+   * @param accessToken The access token.
+   * @param userAgent The specified User Agent.
+   * @param proxyConfig Proxy setting, or set false if don't use proxy.
+   */
+  constructor(
+    url: string,
+    stream: string,
+    params: string | undefined,
+    accessToken: string,
+    userAgent: string,
+    proxyConfig: ProxyConfig | false = false
+  ) {
+    super()
+    this.url = url
+    this.stream = stream
+    if (params === undefined) {
+      this.params = null
+    } else {
+      this.params = params
+    }
+    this.parser = new Parser()
+    this.headers = {
+      'User-Agent': userAgent
+    }
+    this.proxyConfig = proxyConfig
+    this._accessToken = accessToken
+    this._reconnectInterval = 10000
+    this._reconnectMaxAttempts = Infinity
+    this._reconnectCurrentAttempts = 0
+    this._connectionClosed = false
+    this._client = null
+    this._pongReceivedTimestamp = dayjs()
+  }
+
+  /**
+   * Start websocket connection.
+   */
+  public start() {
+    this._connectionClosed = false
+    this._resetRetryParams()
+    this._startWebSocketConnection()
+  }
+
+  /**
+   * Reset connection and start new websocket connection.
+   */
+  private _startWebSocketConnection() {
+    this._resetConnection()
+    this._setupParser()
+    this._client = this._connect(this.url, this.stream, this.params, this._accessToken, this.headers, this.proxyConfig)
+    this._bindSocket(this._client)
+  }
+
+  /**
+   * 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
+    }
+
+    if (this.parser) {
+      this.parser.removeAllListeners()
+    }
+  }
+
+  /**
+   * Resets the parameters used in reconnect.
+   */
+  private _resetRetryParams() {
+    this._reconnectCurrentAttempts = 0
+  }
+
+  /**
+   * 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
+      }
+
+      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.url, this.stream, this.params, this._accessToken, this.headers, this.proxyConfig)
+        this._bindSocket(this._client)
+      }
+    }, this._reconnectInterval)
+  }
+
+  /**
+   * @param url Base url of streaming endpoint.
+   * @param stream The specified stream name.
+   * @param accessToken Access token.
+   * @param headers The specified headers.
+   * @param proxyConfig Proxy setting, or set false if don't use proxy.
+   * @return A WebSocket instance.
+   */
+  private _connect(
+    url: string,
+    stream: string,
+    params: string | null,
+    accessToken: string,
+    headers: { [key: string]: string },
+    proxyConfig: ProxyConfig | false
+  ): WS {
+    const parameter: Array<string> = [`stream=${stream}`]
+
+    if (params) {
+      parameter.push(params)
+    }
+
+    if (accessToken !== null) {
+      parameter.push(`access_token=${accessToken}`)
+    }
+    const requestURL: string = `${url}/?${parameter.join('&')}`
+    let options: WS.ClientOptions = {
+      headers: headers
+    }
+    if (proxyConfig) {
+      options = Object.assign(options, {
+        agent: proxyAgent(proxyConfig)
+      })
+    }
+
+    const cli: WS = new WS(requestURL, options)
+    return cli
+  }
+
+  /**
+   * Clear binding event for web socket 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) => {
+      // Refer the code: https://tools.ietf.org/html/rfc6455#section-7.4
+      if (code === 1000) {
+        this.emit('close', {})
+      } else {
+        console.log(`Closed connection with ${code}`)
+        // If already called close method, it does not retry.
+        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', {})
+      // Call first ping event.
+      setTimeout(() => {
+        client.ping('')
+      }, 10000)
+    })
+    client.on('message', (data: WS.Data, isBinary: boolean) => {
+      this.parser.parse(data, isBinary)
+    })
+    client.on('error', (err: Error) => {
+      this.emit('error', err)
+    })
+  }
+
+  /**
+   * Set up parser when receive message.
+   */
+  private _setupParser() {
+    this.parser.on('update', (status: MastodonAPI.Entity.Status) => {
+      this.emit('update', MastodonAPI.Converter.status(status))
+    })
+    this.parser.on('notification', (notification: MastodonAPI.Entity.Notification) => {
+      const n = MastodonAPI.Converter.notification(notification)
+      if (n instanceof UnknownNotificationTypeError) {
+        console.warn(`Unknown notification event has received: ${notification}`)
+      } else {
+        this.emit('notification', n)
+      }
+    })
+    this.parser.on('delete', (id: string) => {
+      this.emit('delete', id)
+    })
+    this.parser.on('conversation', (conversation: MastodonAPI.Entity.Conversation) => {
+      this.emit('conversation', MastodonAPI.Converter.conversation(conversation))
+    })
+    this.parser.on('status_update', (status: MastodonAPI.Entity.Status) => {
+      this.emit('status_update', MastodonAPI.Converter.status(status))
+    })
+    this.parser.on('error', (err: Error) => {
+      this.emit('parser-error', err)
+    })
+    this.parser.on('heartbeat', _ => {
+      this.emit('heartbeat', 'heartbeat')
+    })
+  }
+
+  /**
+   * 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)
+      }
+    }
+  }
+}
+
+/**
+ * Parser
+ * This class provides parser for websocket message.
+ */
+export class Parser extends EventEmitter {
+  /**
+   * @param message Message body of websocket.
+   */
+  public parse(data: WS.Data, isBinary: boolean) {
+    const message = isBinary ? data : data.toString()
+    if (typeof message !== 'string') {
+      this.emit('heartbeat', {})
+      return
+    }
+
+    if (message === '') {
+      this.emit('heartbeat', {})
+      return
+    }
+
+    let event = ''
+    let payload = ''
+    let mes = {}
+    try {
+      const obj = JSON.parse(message)
+      event = obj.event
+      payload = obj.payload
+      mes = JSON.parse(payload)
+    } catch (err) {
+      // delete event does not have json object
+      if (event !== 'delete') {
+        this.emit('error', new Error(`Error parsing websocket reply: ${message}, error message: ${err}`))
+        return
+      }
+    }
+
+    switch (event) {
+      case 'update':
+        this.emit('update', mes as MastodonAPI.Entity.Status)
+        break
+      case 'notification':
+        this.emit('notification', mes as MastodonAPI.Entity.Notification)
+        break
+      case 'conversation':
+        this.emit('conversation', mes as MastodonAPI.Entity.Conversation)
+        break
+      case 'delete':
+        this.emit('delete', payload)
+        break
+      case 'status.update':
+        this.emit('status_update', mes as MastodonAPI.Entity.Status)
+        break
+      default:
+        this.emit('error', new Error(`Unknown event has received: ${message}`))
+    }
+  }
+}