chore: 🎨 format

This commit is contained in:
ThatOneCalculator 2023-07-13 18:32:23 -07:00
parent 361873c6f4
commit 2e4c30e572
No known key found for this signature in database
GPG key ID: 8703CACD01000000
42 changed files with 1504 additions and 1386 deletions

View file

@ -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"
},

View file

@ -3,25 +3,25 @@
/// <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
}
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;
};
}

View file

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

View file

@ -4,31 +4,31 @@
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>
}
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
}
id: string;
username: string;
url: string;
acct: string;
};
export type AnnouncementStatus = {
id: string
url: string
}
id: string;
url: string;
};
}

View file

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

View file

@ -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
}
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;
};
}

View file

@ -1,49 +1,49 @@
namespace Entity {
export type Sub = {
// For Image, Gifv, and Video
width?: number
height?: number
size?: string
aspect?: number
width?: number;
height?: number;
size?: string;
aspect?: number;
// For Gifv and Video
frame_rate?: string
frame_rate?: string;
// For Audio, Gifv, and Video
duration?: number
bitrate?: number
}
duration?: number;
bitrate?: number;
};
export type Focus = {
x: number
y: number
}
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
}
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
}
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;
};
}

View file

@ -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
}
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;
};
}

View file

@ -2,7 +2,7 @@
namespace Entity {
export type Context = {
ancestors: Array<Status>
descendants: Array<Status>
}
ancestors: Array<Status>;
descendants: Array<Status>;
};
}

View file

@ -3,9 +3,9 @@
namespace Entity {
export type Conversation = {
id: string
accounts: Array<Account>
last_status: Status | null
unread: boolean
}
id: string;
accounts: Array<Account>;
last_status: Status | null;
unread: boolean;
};
}

View file

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

View file

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

View file

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

View file

@ -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
}
id: string;
phrase: string;
context: Array<FilterContext>;
expires_at: string | null;
irreversible: boolean;
whole_word: boolean;
};
export type FilterContext = string
export type FilterContext = string;
}

View file

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

View file

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

View file

@ -4,38 +4,38 @@
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
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
}
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
}
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
}
}
}
max_options: number;
max_characters_per_option: number;
min_expiration: number;
max_expiration: number;
};
};
};
}

View file

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

View file

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

View file

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

View file

@ -3,13 +3,13 @@
namespace Entity {
export type Notification = {
account: Account
created_at: string
id: string
status?: Status
emoji?: string
type: NotificationType
}
account: Account;
created_at: string;
id: string;
status?: Status;
emoji?: string;
type: NotificationType;
};
export type NotificationType = string
export type NotificationType = string;
}

View file

@ -2,13 +2,13 @@
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>
}
id: string;
expires_at: string | null;
expired: boolean;
multiple: boolean;
votes_count: number;
options: Array<PollOption>;
voted: boolean;
own_votes: Array<number>;
};
}

View file

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

View file

@ -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
}
"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;
};
}

View file

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

View file

@ -2,10 +2,10 @@
namespace Entity {
export type Reaction = {
count: number
me: boolean
name: string
url?: string
accounts?: Array<Account>
}
count: number;
me: boolean;
name: string;
url?: string;
accounts?: Array<Account>;
};
}

View file

@ -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
}
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;
};
}

View file

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

View file

@ -4,8 +4,8 @@
namespace Entity {
export type Results = {
accounts: Array<Account>
statuses: Array<Status>
hashtags: Array<Tag>
}
accounts: Array<Account>;
statuses: Array<Status>;
hashtags: Array<Tag>;
};
}

View file

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

View file

@ -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>
}
privacy: string | null;
sensitive: boolean | null;
language: string | null;
note: string;
fields: Array<Field>;
};
}

View file

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

View file

@ -10,36 +10,36 @@
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
}
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;
};
}

View file

@ -10,14 +10,14 @@
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
}
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;
};
}

View file

@ -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
}
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;
};
}

View file

@ -2,9 +2,9 @@
namespace Entity {
export type Tag = {
name: string
url: string
history: Array<History> | null
following?: boolean
}
name: string;
url: string;
history: Array<History> | null;
following?: boolean;
};
}

View file

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

View file

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

View file

@ -1,83 +1,83 @@
import axios, { AxiosResponse, AxiosRequestConfig } from 'axios'
import dayjs from 'dayjs'
import FormData from 'form-data'
import axios, { AxiosResponse, AxiosRequestConfig } from "axios";
import dayjs from "dayjs";
import FormData from "form-data";
import { DEFAULT_UA } from '../default'
import proxyAgent, { ProxyConfig } from '../proxy_config'
import Response from '../response'
import MisskeyEntity from './entity'
import MegalodonEntity from '../entity'
import WebSocket from './web_socket'
import MisskeyNotificationType from './notification'
import NotificationType from '../notification'
import { DEFAULT_UA } from "../default";
import proxyAgent, { ProxyConfig } from "../proxy_config";
import Response from "../response";
import MisskeyEntity from "./entity";
import MegalodonEntity from "../entity";
import WebSocket from "./web_socket";
import MisskeyNotificationType from "./notification";
import NotificationType from "../notification";
namespace MisskeyAPI {
export namespace Entity {
export type App = MisskeyEntity.App
export type Announcement = MisskeyEntity.Announcement
export type Blocking = MisskeyEntity.Blocking
export type Choice = MisskeyEntity.Choice
export type CreatedNote = MisskeyEntity.CreatedNote
export type Emoji = MisskeyEntity.Emoji
export type Favorite = MisskeyEntity.Favorite
export type Field = MisskeyEntity.Field
export type File = MisskeyEntity.File
export type Follower = MisskeyEntity.Follower
export type Following = MisskeyEntity.Following
export type FollowRequest = MisskeyEntity.FollowRequest
export type Hashtag = MisskeyEntity.Hashtag
export type List = MisskeyEntity.List
export type Meta = MisskeyEntity.Meta
export type Mute = MisskeyEntity.Mute
export type Note = MisskeyEntity.Note
export type Notification = MisskeyEntity.Notification
export type Poll = MisskeyEntity.Poll
export type Reaction = MisskeyEntity.Reaction
export type Relation = MisskeyEntity.Relation
export type User = MisskeyEntity.User
export type UserDetail = MisskeyEntity.UserDetail
export type UserDetailMe = MisskeyEntity.UserDetailMe
export type GetAll = MisskeyEntity.GetAll
export type UserKey = MisskeyEntity.UserKey
export type Session = MisskeyEntity.Session
export type Stats = MisskeyEntity.Stats
export type State = MisskeyEntity.State
export type APIEmoji = { emojis: Emoji[] }
export type App = MisskeyEntity.App;
export type Announcement = MisskeyEntity.Announcement;
export type Blocking = MisskeyEntity.Blocking;
export type Choice = MisskeyEntity.Choice;
export type CreatedNote = MisskeyEntity.CreatedNote;
export type Emoji = MisskeyEntity.Emoji;
export type Favorite = MisskeyEntity.Favorite;
export type Field = MisskeyEntity.Field;
export type File = MisskeyEntity.File;
export type Follower = MisskeyEntity.Follower;
export type Following = MisskeyEntity.Following;
export type FollowRequest = MisskeyEntity.FollowRequest;
export type Hashtag = MisskeyEntity.Hashtag;
export type List = MisskeyEntity.List;
export type Meta = MisskeyEntity.Meta;
export type Mute = MisskeyEntity.Mute;
export type Note = MisskeyEntity.Note;
export type Notification = MisskeyEntity.Notification;
export type Poll = MisskeyEntity.Poll;
export type Reaction = MisskeyEntity.Reaction;
export type Relation = MisskeyEntity.Relation;
export type User = MisskeyEntity.User;
export type UserDetail = MisskeyEntity.UserDetail;
export type UserDetailMe = MisskeyEntity.UserDetailMe;
export type GetAll = MisskeyEntity.GetAll;
export type UserKey = MisskeyEntity.UserKey;
export type Session = MisskeyEntity.Session;
export type Stats = MisskeyEntity.Stats;
export type State = MisskeyEntity.State;
export type APIEmoji = { emojis: Emoji[] };
}
export class Converter {
private baseUrl: string
private instanceHost: string
private plcUrl: string
private baseUrl: string;
private instanceHost: string;
private plcUrl: string;
private modelOfAcct = {
id: "1",
username: 'none',
acct: 'none',
display_name: 'none',
username: "none",
acct: "none",
display_name: "none",
locked: true,
bot: true,
discoverable: false,
group: false,
created_at: '1971-01-01T00:00:00.000Z',
note: '',
url: 'plc',
avatar: 'plc',
avatar_static: 'plc',
header: 'plc',
header_static: 'plc',
created_at: "1971-01-01T00:00:00.000Z",
note: "",
url: "plc",
avatar: "plc",
avatar_static: "plc",
header: "plc",
header_static: "plc",
followers_count: -1,
following_count: 0,
statuses_count: 0,
last_status_at: '1971-01-01T00:00:00.000Z',
last_status_at: "1971-01-01T00:00:00.000Z",
noindex: true,
emojis: [],
fields: [],
moved: null
}
moved: null,
};
constructor(baseUrl: string) {
this.baseUrl = baseUrl;
this.instanceHost = baseUrl.substring(baseUrl.indexOf('//') + 2);
this.instanceHost = baseUrl.substring(baseUrl.indexOf("//") + 2);
this.plcUrl = `${baseUrl}/static-assets/transparent.png`;
this.modelOfAcct.url = this.plcUrl;
this.modelOfAcct.avatar = this.plcUrl;
@ -86,17 +86,16 @@ namespace MisskeyAPI {
this.modelOfAcct.header_static = this.plcUrl;
}
// FIXME: Properly render MFM instead of just escaping HTML characters.
escapeMFM = (text: string): string => text
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;')
.replace(/"/g, '&quot;')
.replace(/'/g, '&#39;')
.replace(/`/g, '&#x60;')
.replace(/\r?\n/g, '<br>');
escapeMFM = (text: string): string =>
text
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;")
.replace(/'/g, "&#39;")
.replace(/`/g, "&#x60;")
.replace(/\r?\n/g, "<br>");
emoji = (e: Entity.Emoji): MegalodonEntity.Emoji => {
return {
@ -104,22 +103,22 @@ namespace MisskeyAPI {
static_url: e.url,
url: e.url,
visible_in_picker: true,
category: e.category
}
}
category: e.category,
};
};
field = (f: Entity.Field): MegalodonEntity.Field => ({
name: f.name,
value: this.escapeMFM(f.value),
verified_at: null
})
verified_at: null,
});
user = (u: Entity.User): MegalodonEntity.Account => {
let acct = u.username
let acctUrl = `https://${u.host || this.instanceHost}/@${u.username}`
let acct = u.username;
let acctUrl = `https://${u.host || this.instanceHost}/@${u.username}`;
if (u.host) {
acct = `${u.username}@${u.host}`
acctUrl = `https://${u.host}/@${u.username}`
acct = `${u.username}@${u.host}`;
acctUrl = `https://${u.host}/@${u.username}`;
}
return {
id: u.id,
@ -131,26 +130,31 @@ namespace MisskeyAPI {
followers_count: 0,
following_count: 0,
statuses_count: 0,
note: '',
note: "",
url: acctUrl,
avatar: u.avatarUrl,
avatar_static: u.avatarUrl,
header: this.plcUrl,
header_static: this.plcUrl,
emojis: u.emojis.map(e => this.emoji(e)),
emojis: u.emojis.map((e) => this.emoji(e)),
moved: null,
fields: [],
bot: false
}
}
bot: false,
};
};
userDetail = (u: Entity.UserDetail, host: string): MegalodonEntity.Account => {
let acct = u.username
host = host.replace('https://', '')
let acctUrl = `https://${host || u.host || this.instanceHost}/@${u.username}`
userDetail = (
u: Entity.UserDetail,
host: string,
): MegalodonEntity.Account => {
let acct = u.username;
host = host.replace("https://", "");
let acctUrl = `https://${host || u.host || this.instanceHost}/@${
u.username
}`;
if (u.host) {
acct = `${u.username}@${u.host}`
acctUrl = `https://${u.host}/@${u.username}`
acct = `${u.username}@${u.host}`;
acctUrl = `https://${u.host}/@${u.username}`;
}
return {
id: u.id,
@ -162,70 +166,79 @@ namespace MisskeyAPI {
followers_count: u.followersCount,
following_count: u.followingCount,
statuses_count: u.notesCount,
note: u.description?.replace(/\n|\\n/g, '<br>') ?? '',
note: u.description?.replace(/\n|\\n/g, "<br>") ?? "",
url: acctUrl,
avatar: u.avatarUrl,
avatar_static: u.avatarUrl,
header: u.bannerUrl ?? this.plcUrl,
header_static: u.bannerUrl ?? this.plcUrl,
emojis: u.emojis.map(e => this.emoji(e)),
emojis: u.emojis.map((e) => this.emoji(e)),
moved: null,
fields: u.fields.map(f => this.field(f)),
fields: u.fields.map((f) => this.field(f)),
bot: u.isBot,
}
}
};
};
userPreferences = (u: MisskeyAPI.Entity.UserDetailMe, v: 'public' | 'unlisted' | 'private' | 'direct'): MegalodonEntity.Preferences => {
userPreferences = (
u: MisskeyAPI.Entity.UserDetailMe,
v: "public" | "unlisted" | "private" | "direct",
): MegalodonEntity.Preferences => {
return {
"reading:expand:media": "default",
"reading:expand:spoilers": false,
"posting:default:language": u.lang,
"posting:default:sensitive": u.alwaysMarkNsfw,
"posting:default:visibility": v
}
}
"posting:default:visibility": v,
};
};
visibility = (v: 'public' | 'home' | 'followers' | 'specified'): 'public' | 'unlisted' | 'private' | 'direct' => {
visibility = (
v: "public" | "home" | "followers" | "specified",
): "public" | "unlisted" | "private" | "direct" => {
switch (v) {
case 'public':
return v
case 'home':
return 'unlisted'
case 'followers':
return 'private'
case 'specified':
return 'direct'
}
case "public":
return v;
case "home":
return "unlisted";
case "followers":
return "private";
case "specified":
return "direct";
}
};
encodeVisibility = (v: 'public' | 'unlisted' | 'private' | 'direct'): 'public' | 'home' | 'followers' | 'specified' => {
encodeVisibility = (
v: "public" | "unlisted" | "private" | "direct",
): "public" | "home" | "followers" | "specified" => {
switch (v) {
case 'public':
return v
case 'unlisted':
return 'home'
case 'private':
return 'followers'
case 'direct':
return 'specified'
}
case "public":
return v;
case "unlisted":
return "home";
case "private":
return "followers";
case "direct":
return "specified";
}
};
fileType = (s: string): 'unknown' | 'image' | 'gifv' | 'video' | 'audio' => {
if (s === 'image/gif') {
return 'gifv'
fileType = (
s: string,
): "unknown" | "image" | "gifv" | "video" | "audio" => {
if (s === "image/gif") {
return "gifv";
}
if (s.includes('image')) {
return 'image'
if (s.includes("image")) {
return "image";
}
if (s.includes('video')) {
return 'video'
if (s.includes("video")) {
return "video";
}
if (s.includes('audio')) {
return 'audio'
}
return 'unknown'
if (s.includes("audio")) {
return "audio";
}
return "unknown";
};
file = (f: Entity.File): MegalodonEntity.Attachment => {
return {
@ -237,20 +250,20 @@ namespace MisskeyAPI {
text_url: f.url,
meta: {
width: f.properties.width,
height: f.properties.height
height: f.properties.height,
},
description: f.comment,
blurhash: f.blurhash
}
}
blurhash: f.blurhash,
};
};
follower = (f: Entity.Follower): MegalodonEntity.Account => {
return this.user(f.follower)
}
return this.user(f.follower);
};
following = (f: Entity.Following): MegalodonEntity.Account => {
return this.user(f.followee)
}
return this.user(f.followee);
};
relation = (r: Entity.Relation): MegalodonEntity.Relationship => {
return {
@ -265,35 +278,37 @@ namespace MisskeyAPI {
domain_blocking: false,
showing_reblogs: true,
endorsed: false,
notifying: false
}
}
notifying: false,
};
};
choice = (c: Entity.Choice): MegalodonEntity.PollOption => {
return {
title: c.text,
votes_count: c.votes
}
}
votes_count: c.votes,
};
};
poll = (p: Entity.Poll, id: string): MegalodonEntity.Poll => {
const now = dayjs()
const expire = dayjs(p.expiresAt)
const count = p.choices.reduce((sum, choice) => sum + choice.votes, 0)
const now = dayjs();
const expire = dayjs(p.expiresAt);
const count = p.choices.reduce((sum, choice) => sum + choice.votes, 0);
return {
id: id,
expires_at: p.expiresAt,
expired: now.isAfter(expire),
multiple: p.multiple,
votes_count: count,
options: p.choices.map(c => this.choice(c)),
voted: p.choices.some(c => c.isVoted),
own_votes: p.choices.filter(c => c.isVoted).map(c => p.choices.indexOf(c))
}
}
options: p.choices.map((c) => this.choice(c)),
voted: p.choices.some((c) => c.isVoted),
own_votes: p.choices
.filter((c) => c.isVoted)
.map((c) => p.choices.indexOf(c)),
};
};
note = (n: Entity.Note, host: string): MegalodonEntity.Status => {
host = host.replace('https://', '')
host = host.replace("https://", "");
return {
id: n.id,
@ -303,20 +318,20 @@ namespace MisskeyAPI {
in_reply_to_id: n.replyId,
in_reply_to_account_id: n.reply?.userId ?? null,
reblog: n.renote ? this.note(n.renote, host) : null,
content: n.text ? this.escapeMFM(n.text) : '',
content: n.text ? this.escapeMFM(n.text) : "",
plain_content: n.text ? n.text : null,
created_at: n.createdAt,
emojis: n.emojis.map(e => this.emoji(e)),
emojis: n.emojis.map((e) => this.emoji(e)),
replies_count: n.repliesCount,
reblogs_count: n.renoteCount,
favourites_count: this.getTotalReactions(n.reactions),
reblogged: false,
favourited: !!n.myReaction,
muted: false,
sensitive: n.files ? n.files.some(f => f.isSensitive) : false,
spoiler_text: n.cw ? n.cw : '',
sensitive: n.files ? n.files.some((f) => f.isSensitive) : false,
spoiler_text: n.cw ? n.cw : "",
visibility: this.visibility(n.visibility),
media_attachments: n.files ? n.files.map(f => this.file(f)) : [],
media_attachments: n.files ? n.files.map((f) => this.file(f)) : [],
mentions: [],
tags: [],
card: null,
@ -326,110 +341,124 @@ namespace MisskeyAPI {
pinned: null,
emoji_reactions: this.mapReactions(n.reactions, n.myReaction),
bookmarked: false,
quote: n.renote && n.text ? this.note(n.renote, host) : null
}
}
quote: n.renote && n.text ? this.note(n.renote, host) : null,
};
};
mapReactions = (r: { [key: string]: number }, myReaction?: string): Array<MegalodonEntity.Reaction> => {
return Object.keys(r).map(key => {
mapReactions = (
r: { [key: string]: number },
myReaction?: string,
): Array<MegalodonEntity.Reaction> => {
return Object.keys(r).map((key) => {
if (myReaction && key === myReaction) {
return {
count: r[key],
me: true,
name: key
}
name: key,
};
}
return {
count: r[key],
me: false,
name: key
}
})
}
name: key,
};
});
};
getTotalReactions = (r: { [key: string]: number }): number => {
return Object.values(r).length > 0 ? Object.values(r).reduce((previousValue, currentValue) => previousValue + currentValue) : 0
}
return Object.values(r).length > 0
? Object.values(r).reduce(
(previousValue, currentValue) => previousValue + currentValue,
)
: 0;
};
reactions = (r: Array<Entity.Reaction>): Array<MegalodonEntity.Reaction> => {
const result: Array<MegalodonEntity.Reaction> = []
reactions = (
r: Array<Entity.Reaction>,
): Array<MegalodonEntity.Reaction> => {
const result: Array<MegalodonEntity.Reaction> = [];
for (const e of r) {
const i = result.findIndex(res => res.name === e.type)
const i = result.findIndex((res) => res.name === e.type);
if (i >= 0) {
result[i].count++
result[i].count++;
} else {
result.push({
count: 1,
me: false,
name: e.type
})
name: e.type,
});
}
}
return result
}
return result;
};
noteToConversation = (n: Entity.Note, host: string): MegalodonEntity.Conversation => {
const accounts: Array<MegalodonEntity.Account> = [this.user(n.user)]
noteToConversation = (
n: Entity.Note,
host: string,
): MegalodonEntity.Conversation => {
const accounts: Array<MegalodonEntity.Account> = [this.user(n.user)];
if (n.reply) {
accounts.push(this.user(n.reply.user))
accounts.push(this.user(n.reply.user));
}
return {
id: n.id,
accounts: accounts,
last_status: this.note(n, host),
unread: false
}
}
unread: false,
};
};
list = (l: Entity.List): MegalodonEntity.List => ({
id: l.id,
title: l.name
})
title: l.name,
});
encodeNotificationType = (e: MegalodonEntity.NotificationType): MisskeyEntity.NotificationType => {
encodeNotificationType = (
e: MegalodonEntity.NotificationType,
): MisskeyEntity.NotificationType => {
switch (e) {
case NotificationType.Follow:
return MisskeyNotificationType.Follow
return MisskeyNotificationType.Follow;
case NotificationType.Mention:
return MisskeyNotificationType.Reply
return MisskeyNotificationType.Reply;
case NotificationType.Favourite:
case NotificationType.EmojiReaction:
return MisskeyNotificationType.Reaction
return MisskeyNotificationType.Reaction;
case NotificationType.Reblog:
return MisskeyNotificationType.Renote
return MisskeyNotificationType.Renote;
case NotificationType.Poll:
return MisskeyNotificationType.PollEnded
return MisskeyNotificationType.PollEnded;
case NotificationType.FollowRequest:
return MisskeyNotificationType.ReceiveFollowRequest
return MisskeyNotificationType.ReceiveFollowRequest;
default:
return e
}
return e;
}
};
decodeNotificationType = (e: MisskeyEntity.NotificationType): MegalodonEntity.NotificationType => {
decodeNotificationType = (
e: MisskeyEntity.NotificationType,
): MegalodonEntity.NotificationType => {
switch (e) {
case MisskeyNotificationType.Follow:
return NotificationType.Follow
return NotificationType.Follow;
case MisskeyNotificationType.Mention:
case MisskeyNotificationType.Reply:
return NotificationType.Mention
return NotificationType.Mention;
case MisskeyNotificationType.Renote:
case MisskeyNotificationType.Quote:
return NotificationType.Reblog
return NotificationType.Reblog;
case MisskeyNotificationType.Reaction:
return NotificationType.EmojiReaction
return NotificationType.EmojiReaction;
case MisskeyNotificationType.PollEnded:
return NotificationType.Poll
return NotificationType.Poll;
case MisskeyNotificationType.ReceiveFollowRequest:
return NotificationType.FollowRequest
return NotificationType.FollowRequest;
case MisskeyNotificationType.FollowRequestAccepted:
return NotificationType.Follow
return NotificationType.Follow;
default:
return e
return e;
}
}
};
announcement = (a: Entity.Announcement): MegalodonEntity.Announcement => ({
id: a.id,
@ -446,43 +475,46 @@ namespace MisskeyAPI {
tags: [],
emojis: [],
reactions: [],
})
});
notification = (n: Entity.Notification, host: string): MegalodonEntity.Notification => {
notification = (
n: Entity.Notification,
host: string,
): MegalodonEntity.Notification => {
let notification = {
id: n.id,
account: n.user ? this.user(n.user) : this.modelOfAcct,
created_at: n.createdAt,
type: this.decodeNotificationType(n.type)
}
type: this.decodeNotificationType(n.type),
};
if (n.note) {
notification = Object.assign(notification, {
status: this.note(n.note, host)
})
status: this.note(n.note, host),
});
if (notification.type === NotificationType.Poll) {
notification = Object.assign(notification, {
account: this.note(n.note, host).account
})
account: this.note(n.note, host).account,
});
}
}
if (n.reaction) {
notification = Object.assign(notification, {
emoji: n.reaction
})
}
return notification
emoji: n.reaction,
});
}
return notification;
};
stats = (s: Entity.Stats): MegalodonEntity.Stats => {
return {
user_count: s.usersCount,
status_count: s.notesCount,
domain_count: s.instances
}
}
domain_count: s.instances,
};
};
meta = (m: Entity.Meta, s: Entity.Stats): MegalodonEntity.Instance => {
const wss = m.uri.replace(/^https:\/\//, 'wss://')
const wss = m.uri.replace(/^https:\/\//, "wss://");
return {
uri: m.uri,
title: m.name,
@ -491,54 +523,67 @@ namespace MisskeyAPI {
version: m.version,
thumbnail: m.bannerUrl,
urls: {
streaming_api: `${wss}/streaming`
streaming_api: `${wss}/streaming`,
},
stats: this.stats(s),
languages: m.langs,
contact_account: null,
max_toot_chars: m.maxNoteTextLength,
registrations: !m.disableRegistration
}
}
registrations: !m.disableRegistration,
};
};
hashtag = (h: Entity.Hashtag): MegalodonEntity.Tag => {
return {
name: h.tag,
url: h.tag,
history: null,
following: false
}
}
following: false,
};
};
}
export const DEFAULT_SCOPE = [
'read:account',
'write:account',
'read:blocks',
'write:blocks',
'read:drive',
'write:drive',
'read:favorites',
'write:favorites',
'read:following',
'write:following',
'read:mutes',
'write:mutes',
'write:notes',
'read:notifications',
'write:notifications',
'read:reactions',
'write:reactions',
'write:votes'
]
"read:account",
"write:account",
"read:blocks",
"write:blocks",
"read:drive",
"write:drive",
"read:favorites",
"write:favorites",
"read:following",
"write:following",
"read:mutes",
"write:mutes",
"write:notes",
"read:notifications",
"write:notifications",
"read:reactions",
"write:reactions",
"write:votes",
];
/**
* Interface
*/
export interface Interface {
post<T = any>(path: string, params?: any, headers?: { [key: string]: string }): Promise<Response<T>>
cancel(): void
socket(channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list', listId?: string): WebSocket
post<T = any>(
path: string,
params?: any,
headers?: { [key: string]: string },
): Promise<Response<T>>;
cancel(): void;
socket(
channel:
| "user"
| "localTimeline"
| "hybridTimeline"
| "globalTimeline"
| "conversation"
| "list",
listId?: string,
): WebSocket;
}
/**
@ -547,12 +592,12 @@ namespace MisskeyAPI {
* Usign axios for request, you will handle promises.
*/
export class Client implements Interface {
private accessToken: string | null
private baseUrl: string
private userAgent: string
private abortController: AbortController
private proxyConfig: ProxyConfig | false = false
private converter: Converter
private accessToken: string | null;
private baseUrl: string;
private userAgent: string;
private abortController: AbortController;
private proxyConfig: ProxyConfig | false = false;
private converter: Converter;
/**
* @param baseUrl hostname or base URL
@ -561,14 +606,20 @@ namespace MisskeyAPI {
* @param proxyConfig Proxy setting, or set false if don't use proxy.
* @param converter Converter instance.
*/
constructor(baseUrl: string, accessToken: string | null, userAgent: string = DEFAULT_UA, proxyConfig: ProxyConfig | false = false, converter: Converter) {
this.accessToken = accessToken
this.baseUrl = baseUrl
this.userAgent = userAgent
this.proxyConfig = proxyConfig
this.abortController = new AbortController()
this.converter = converter
axios.defaults.signal = this.abortController.signal
constructor(
baseUrl: string,
accessToken: string | null,
userAgent: string = DEFAULT_UA,
proxyConfig: ProxyConfig | false = false,
converter: Converter,
) {
this.accessToken = accessToken;
this.baseUrl = baseUrl;
this.userAgent = userAgent;
this.proxyConfig = proxyConfig;
this.abortController = new AbortController();
this.converter = converter;
axios.defaults.signal = this.abortController.signal;
}
/**
@ -577,38 +628,44 @@ namespace MisskeyAPI {
* @param params Form data
* @param headers Request header object
*/
public async post<T>(path: string, params: any = {}, headers: { [key: string]: string } = {}): Promise<Response<T>> {
public async post<T>(
path: string,
params: any = {},
headers: { [key: string]: string } = {},
): Promise<Response<T>> {
let options: AxiosRequestConfig = {
headers: headers,
maxContentLength: Infinity,
maxBodyLength: Infinity
}
maxBodyLength: Infinity,
};
if (this.proxyConfig) {
options = Object.assign(options, {
httpAgent: proxyAgent(this.proxyConfig),
httpsAgent: proxyAgent(this.proxyConfig)
})
httpsAgent: proxyAgent(this.proxyConfig),
});
}
let bodyParams = params
let bodyParams = params;
if (this.accessToken) {
if (params instanceof FormData) {
bodyParams.append('i', this.accessToken)
bodyParams.append("i", this.accessToken);
} else {
bodyParams = Object.assign(params, {
i: this.accessToken
})
i: this.accessToken,
});
}
}
return axios.post<T>(this.baseUrl + path, bodyParams, options).then((resp: AxiosResponse<T>) => {
return axios
.post<T>(this.baseUrl + path, bodyParams, options)
.then((resp: AxiosResponse<T>) => {
const res: Response<T> = {
data: resp.data,
status: resp.status,
statusText: resp.statusText,
headers: resp.headers
}
return res
})
headers: resp.headers,
};
return res;
});
}
/**
@ -616,7 +673,7 @@ namespace MisskeyAPI {
* @returns void
*/
public cancel(): void {
return this.abortController.abort()
return this.abortController.abort();
}
/**
@ -626,20 +683,34 @@ namespace MisskeyAPI {
* @param listId This parameter is required only list channel.
*/
public socket(
channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list',
listId?: string
channel:
| "user"
| "localTimeline"
| "hybridTimeline"
| "globalTimeline"
| "conversation"
| "list",
listId?: string,
): WebSocket {
if (!this.accessToken) {
throw new Error('accessToken is required')
throw new Error("accessToken is required");
}
const url = `${this.baseUrl}/streaming`
const streaming = new WebSocket(url, channel, this.accessToken, listId, this.userAgent, this.proxyConfig, this.converter)
const url = `${this.baseUrl}/streaming`;
const streaming = new WebSocket(
url,
channel,
this.accessToken,
listId,
this.userAgent,
this.proxyConfig,
this.converter,
);
process.nextTick(() => {
streaming.start()
})
return streaming
streaming.start();
});
return streaming;
}
}
}
export default MisskeyAPI
export default MisskeyAPI;

View file

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

View file

@ -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;

View file

@ -1,34 +1,43 @@
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
@ -38,66 +47,72 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
*/
constructor(
url: string,
channel: 'user' | 'localTimeline' | 'hybridTimeline' | 'globalTimeline' | 'conversation' | 'list',
channel:
| "user"
| "localTimeline"
| "hybridTimeline"
| "globalTimeline"
| "conversation"
| "list",
accessToken: string,
listId: string | undefined,
userAgent: string,
proxyConfig: ProxyConfig | false = false,
converter: MisskeyAPI.Converter
converter: MisskeyAPI.Converter,
) {
super()
this.url = url
this.parser = new Parser()
this.channel = channel
super();
this.url = url;
this.parser = new Parser();
this.channel = channel;
this.headers = {
'User-Agent': userAgent
}
"User-Agent": userAgent,
};
if (listId === undefined) {
this.listId = null
this.listId = null;
} else {
this.listId = listId
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
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()
this._connectionClosed = false;
this._resetRetryParams();
this._startWebSocketConnection();
}
private baseUrlToHost(baseUrl: string): string {
return baseUrl.replace('https://', '')
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)
this._resetConnection();
this._setupParser();
this._client = this._connect();
this._bindSocket(this._client);
}
/**
* Stop current connection.
*/
public stop() {
this._connectionClosed = true
this._resetConnection()
this._resetRetryParams()
this._connectionClosed = true;
this._resetConnection();
this._resetRetryParams();
}
/**
@ -105,13 +120,13 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
*/
private _resetConnection() {
if (this._client) {
this._client.close(1000)
this._client.removeAllListeners()
this._client = null
this._client.close(1000);
this._client.removeAllListeners();
this._client = null;
}
if (this.parser) {
this.parser.removeAllListeners()
this.parser.removeAllListeners();
}
}
@ -119,7 +134,7 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
* Resets the parameters used in reconnect.
*/
private _resetRetryParams() {
this._reconnectCurrentAttempts = 0
this._reconnectCurrentAttempts = 0;
}
/**
@ -127,15 +142,15 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
*/
private _connect(): WS {
let options: WS.ClientOptions = {
headers: this.headers
}
headers: this.headers,
};
if (this.proxyConfig) {
options = Object.assign(options, {
agent: proxyAgent(this.proxyConfig)
})
agent: proxyAgent(this.proxyConfig),
});
}
const cli: WS = new WS(`${this.url}?i=${this._accessToken}`, options)
return cli
const cli: WS = new WS(`${this.url}?i=${this._accessToken}`, options);
return cli;
}
/**
@ -143,65 +158,65 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
*/
private _channel() {
if (!this._client) {
return
return;
}
switch (this.channel) {
case 'conversation':
case "conversation":
this._client.send(
JSON.stringify({
type: 'connect',
type: "connect",
body: {
channel: 'main',
id: this._channelID
}
})
)
break
case 'user':
channel: "main",
id: this._channelID,
},
}),
);
break;
case "user":
this._client.send(
JSON.stringify({
type: 'connect',
type: "connect",
body: {
channel: 'main',
id: this._channelID
}
})
)
channel: "main",
id: this._channelID,
},
}),
);
this._client.send(
JSON.stringify({
type: 'connect',
type: "connect",
body: {
channel: 'homeTimeline',
id: this._channelID
}
})
)
break
case 'list':
channel: "homeTimeline",
id: this._channelID,
},
}),
);
break;
case "list":
this._client.send(
JSON.stringify({
type: 'connect',
type: "connect",
body: {
channel: 'userList',
channel: "userList",
id: this._channelID,
params: {
listId: this.listId
}
}
})
)
break
listId: this.listId,
},
},
}),
);
break;
default:
this._client.send(
JSON.stringify({
type: 'connect',
type: "connect",
body: {
channel: this.channel,
id: this._channelID
}
})
)
break
id: this._channelID,
},
}),
);
break;
}
}
@ -214,23 +229,23 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
// 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
return;
}
if (this._reconnectCurrentAttempts < this._reconnectMaxAttempts) {
this._reconnectCurrentAttempts++
this._clearBinding()
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()
this._client.terminate();
}
// Call connect methods
console.log('Reconnecting')
this._client = this._connect()
this._bindSocket(this._client)
console.log("Reconnecting");
this._client = this._connect();
this._bindSocket(this._client);
}
}, this._reconnectInterval)
}, this._reconnectInterval);
}
/**
@ -238,11 +253,11 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
*/
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')
this._client.removeAllListeners("close");
this._client.removeAllListeners("pong");
this._client.removeAllListeners("open");
this._client.removeAllListeners("message");
this._client.removeAllListeners("error");
}
}
@ -251,76 +266,97 @@ export default class WebSocket extends EventEmitter implements WebSocketInterfac
* @param client A WebSocket instance.
*/
private _bindSocket(client: WS) {
client.on('close', (code: number, _reason: Buffer) => {
client.on("close", (code: number, _reason: Buffer) => {
if (code === 1000) {
this.emit('close', {})
this.emit("close", {});
} else {
console.log(`Closed connection with ${code}`)
console.log(`Closed connection with ${code}`);
if (!this._connectionClosed) {
this._reconnect()
this._reconnect();
}
}
})
client.on('pong', () => {
this._pongWaiting = false
this.emit('pong', {})
this._pongReceivedTimestamp = dayjs()
});
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()
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)
})
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)
})
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()
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) {
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('')
this._pongWaiting = true;
this._client.ping("");
setTimeout(() => {
if (this._pongWaiting) {
this._pongWaiting = false
this._reconnect()
this._pongWaiting = false;
this._reconnect();
}
}, 10000)
}, 10000);
}
}
}
@ -336,79 +372,87 @@ export class Parser extends EventEmitter {
* @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
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
type: string;
body: {
id: string
type: string
body: any
}
}
id: string;
type: string;
body: any;
};
};
let body: {
id: string
type: string
body: any
}
id: string;
type: string;
body: any;
};
try {
obj = JSON.parse(message)
if (obj.type !== 'channel') {
return
obj = JSON.parse(message);
if (obj.type !== "channel") {
return;
}
if (!obj.body) {
return
return;
}
body = obj.body
body = obj.body;
if (body.id !== channelID) {
return
return;
}
} catch (err) {
this.emit('error', new Error(`Error parsing websocket reply: ${message}, error message: ${err}`))
return
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)
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
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':
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
break;
default:
this.emit('error', new Error(`Unknown event has received: ${JSON.stringify(body)}`))
break
this.emit(
"error",
new Error(`Unknown event has received: ${JSON.stringify(body)}`),
);
break;
}
}
}