hischool.js 0.0.1

package/lib/esm/events/v1.js

@@ -0,0 +1,514 @@
+import { hydrate } from "../hydration/index.js";
+import { ReactiveSet } from "@solid-primitives/set";
+import { batch } from "solid-js";
+/**
+ * Handle an event for the Client
+ * @param client Client
+ * @param event Event
+ * @param setReady Signal state change
+ */
+export async function handleEvent(client, event, setReady) {
+    if (client.options.debug) {
+        console.debug("[S->C]", event);
+    }
+    switch (event.type) {
+        case "Bulk": {
+            for (const item of event.v) {
+                handleEvent(client, item, setReady);
+            }
+            break;
+        }
+        case "Ready": {
+            batch(() => {
+                for (const user of event.users) {
+                    const u = client.users.getOrCreate(user._id, user);
+                    if (u.relationship === "User") {
+                        client.user = u;
+                    }
+                }
+                for (const server of event.servers) {
+                    client.servers.getOrCreate(server._id, server);
+                }
+                for (const member of event.members) {
+                    client.serverMembers.getOrCreate(member._id, member);
+                }
+                for (const channel of event.channels) {
+                    client.channels.getOrCreate(channel._id, channel);
+                }
+                for (const emoji of event.emojis) {
+                    client.emojis.getOrCreate(emoji._id, emoji);
+                }
+            });
+            if (client.options.syncUnreads) {
+                await client.channelUnreads.sync();
+            }
+            setReady(true);
+            client.emit("ready");
+            break;
+        }
+        case "Message": {
+            if (!client.messages.has(event._id)) {
+                // TODO: this should not be necessary in future protocols:
+                if (event.author &&
+                    event.author != "00000000000000000000000000" &&
+                    !event.webhook &&
+                    // TODO: this is causing a lot of extra requests!
+                    // usually 2 extra requests before a message can come through!!
+                    client.options.eagerFetching) {
+                    await client.users.fetch(event.author);
+                    const serverId = client.channels.get(event.channel)?.serverId;
+                    if (serverId)
+                        await client.serverMembers.fetch(serverId, event.author);
+                }
+                batch(() => {
+                    client.messages.getOrCreate(event._id, event, true);
+                    client.channels.updateUnderlyingObject(event.channel, "lastMessageId", event._id);
+                });
+            }
+            break;
+        }
+        case "MessageUpdate": {
+            const message = client.messages.getOrPartial(event.id);
+            if (message) {
+                const previousMessage = {
+                    ...client.messages.getUnderlyingObject(event.id),
+                    channelId: event.channel,
+                };
+                client.messages.updateUnderlyingObject(event.id, {
+                    ...hydrate("message", { ...event.data, channel: event.channel }, client, false),
+                    editedAt: new Date(),
+                });
+                client.emit("messageUpdate", message, previousMessage);
+            }
+            break;
+        }
+        case "MessageAppend": {
+            const message = client.messages.getOrPartial(event.id);
+            if (message) {
+                const previousMessage = {
+                    ...client.messages.getUnderlyingObject(event.id),
+                    channelId: event.channel,
+                };
+                client.messages.updateUnderlyingObject(event.id, "embeds", (embeds) => [...(embeds ?? []), event.append.embeds ?? []]);
+                client.messages.updateUnderlyingObject(event.id, "channelId", event.channel);
+                client.emit("messageUpdate", message, previousMessage);
+            }
+            break;
+        }
+        case "MessageDelete": {
+            if (client.messages.getOrPartial(event.id)) {
+                const message = client.messages.getUnderlyingObject(event.id);
+                client.emit("messageDelete", message);
+                client.messages.delete(event.id);
+            }
+            break;
+        }
+        case "BulkMessageDelete": {
+            batch(() => client.emit("messageDeleteBulk", event.ids
+                .map((id) => {
+                if (client.messages.has(id)) {
+                    const message = client.messages.getUnderlyingObject(id);
+                    client.messages.delete(id);
+                    return message;
+                }
+                return undefined;
+            })
+                .filter((x) => x), client.channels.get(event.channel)));
+            break;
+        }
+        case "MessageReact": {
+            const message = client.messages.getOrPartial(event.id);
+            if (message) {
+                const reactions = message.reactions;
+                const set = reactions.get(event.emoji_id);
+                if (set) {
+                    if (set.has(event.user_id))
+                        return;
+                    set.add(event.user_id);
+                }
+                else {
+                    reactions.set(event.emoji_id, new ReactiveSet([event.user_id]));
+                }
+                client.emit("messageReactionAdd", message, event.user_id, event.emoji_id);
+            }
+            break;
+        }
+        case "MessageUnreact": {
+            const message = client.messages.getOrPartial(event.id);
+            if (message) {
+                const set = message.reactions.get(event.emoji_id);
+                if (set?.has(event.user_id)) {
+                    set.delete(event.user_id);
+                }
+                else if (!client.messages.isPartial(event.id)) {
+                    return;
+                }
+                client.emit("messageReactionRemove", message, event.user_id, event.emoji_id);
+            }
+            break;
+        }
+        case "MessageRemoveReaction": {
+            const message = client.messages.getOrPartial(event.id);
+            if (message) {
+                const reactions = message.reactions;
+                if (reactions.has(event.emoji_id)) {
+                    reactions.delete(event.emoji_id);
+                }
+                else if (!client.messages.isPartial(event.id)) {
+                    return;
+                }
+                client.emit("messageReactionRemoveEmoji", message, event.emoji_id);
+            }
+            break;
+        }
+        case "ChannelCreate": {
+            if (!client.channels.has(event._id)) {
+                client.channels.getOrCreate(event._id, event, true);
+            }
+            break;
+        }
+        case "ChannelUpdate": {
+            const channel = client.channels.getOrPartial(event.id);
+            if (channel) {
+                const previousChannel = {
+                    ...client.channels.getUnderlyingObject(event.id),
+                };
+                const changes = hydrate("channel", event.data, client, false);
+                if (event.clear) {
+                    for (const remove of event.clear) {
+                        switch (remove) {
+                            case "Description":
+                                changes["description"] = undefined;
+                                break;
+                            case "DefaultPermissions":
+                                changes["defaultPermissions"] = undefined;
+                                break;
+                            case "Icon":
+                                changes["icon"] = undefined;
+                                break;
+                        }
+                    }
+                }
+                client.channels.updateUnderlyingObject(event.id, changes);
+                client.emit("channelUpdate", channel, previousChannel);
+            }
+            break;
+        }
+        case "ChannelDelete": {
+            if (client.channels.getOrPartial(event.id)) {
+                const channel = client.channels.getUnderlyingObject(event.id);
+                client.emit("channelDelete", channel);
+                client.channels.delete(event.id);
+            }
+            break;
+        }
+        case "ChannelGroupJoin": {
+            const channel = client.channels.getOrPartial(event.id);
+            if (channel) {
+                if (!channel.recipientIds.has(event.user)) {
+                    channel.recipientIds.add(event.user);
+                }
+                else if (!client.channels.isPartial(event.id)) {
+                    return;
+                }
+                client.emit("channelGroupJoin", channel, await client.users.fetch(event.user));
+            }
+            break;
+        }
+        case "ChannelGroupLeave": {
+            const channel = client.channels.getOrPartial(event.id);
+            if (channel) {
+                if (channel.recipientIds.has(event.user)) {
+                    channel.recipientIds.delete(event.user);
+                }
+                else if (!client.channels.isPartial(event.id)) {
+                    return;
+                }
+                client.emit("channelGroupLeave", channel, client.users.getOrPartial(event.user));
+            }
+            break;
+        }
+        case "ChannelStartTyping": {
+            const channel = client.channels.getOrPartial(event.id);
+            if (channel) {
+                if (!channel.typingIds.has(event.user)) {
+                    channel.typingIds.add(event.user);
+                }
+                else if (!client.channels.isPartial(event.id)) {
+                    return;
+                }
+                client.emit("channelStartTyping", channel, client.users.getOrPartial(event.user));
+            }
+            break;
+        }
+        case "ChannelStopTyping": {
+            const channel = client.channels.getOrPartial(event.id);
+            if (channel) {
+                if (channel.typingIds.has(event.user)) {
+                    channel.typingIds.delete(event.user);
+                }
+                else if (!client.channels.isPartial(event.id)) {
+                    return;
+                }
+                client.emit("channelStopTyping", channel, client.users.getOrPartial(event.user));
+            }
+            break;
+        }
+        case "ChannelAck": {
+            const channel = client.channels.getOrPartial(event.id);
+            if (channel) {
+                client.emit("channelAcknowledged", channel, event.message_id);
+            }
+            break;
+        }
+        case "ServerCreate": {
+            if (!client.servers.has(event.server._id)) {
+                batch(() => {
+                    for (const channel of event.channels) {
+                        client.channels.getOrCreate(channel._id, channel);
+                    }
+                    client.servers.getOrCreate(event.server._id, event.server, true);
+                });
+            }
+            break;
+        }
+        case "ServerUpdate": {
+            const server = client.servers.getOrPartial(event.id);
+            if (server) {
+                const previousServer = {
+                    ...client.servers.getUnderlyingObject(event.id),
+                };
+                const changes = hydrate("server", event.data, client, false);
+                if (event.clear) {
+                    for (const remove of event.clear) {
+                        switch (remove) {
+                            case "Banner":
+                                changes["banner"] = undefined;
+                                break;
+                            case "Categories":
+                                changes["categories"] = undefined;
+                                break;
+                            case "SystemMessages":
+                                changes["systemMessages"] = undefined;
+                                break;
+                            case "Description":
+                                changes["description"] = undefined;
+                                break;
+                            case "Icon":
+                                changes["icon"] = undefined;
+                                break;
+                        }
+                    }
+                }
+                client.servers.updateUnderlyingObject(event.id, changes);
+                client.emit("serverUpdate", server, previousServer);
+            }
+            break;
+        }
+        case "ServerDelete": {
+            const server = client.servers.getOrPartial(event.id);
+            if (server) {
+                // TODO: server should tell us if it's a leave or delete on our end
+                server.$delete();
+            }
+            break;
+        }
+        case "ServerRoleUpdate": {
+            const server = client.servers.getOrPartial(event.id);
+            if (server) {
+                const role = server.roles.get(event.role_id) ?? {};
+                server.roles.set(event.role_id, {
+                    ...role,
+                    ...event.data,
+                });
+                client.emit("serverRoleUpdate", server, event.role_id, role);
+            }
+            break;
+        }
+        case "ServerRoleDelete": {
+            const server = client.servers.getOrPartial(event.id);
+            if (server) {
+                let role = {};
+                const roles = server.roles;
+                if (roles.has(event.role_id)) {
+                    role = roles.get(event.role_id);
+                    roles.delete(event.role_id);
+                }
+                else if (!client.servers.isPartial(event.id)) {
+                    return;
+                }
+                client.emit("serverRoleDelete", server, event.role_id, role);
+            }
+            break;
+        }
+        case "ServerMemberJoin": {
+            const id = {
+                server: event.id,
+                user: event.user,
+            };
+            if (!client.serverMembers.hasByKey(id)) {
+                if (!client.users.has(id.user)) {
+                    if (client.options.eagerFetching) {
+                        await client.users.fetch(id.user);
+                    }
+                }
+                client.emit("serverMemberJoin", client.serverMembers.getOrCreate(id, {
+                    _id: id,
+                    joined_at: new Date().toUTCString(),
+                }));
+            }
+            break;
+        }
+        case "ServerMemberUpdate": {
+            const member = client.serverMembers.getOrPartial(event.id);
+            if (member) {
+                const previousMember = {
+                    ...client.serverMembers.getUnderlyingObject(event.id.server + event.id.user),
+                };
+                const changes = hydrate("serverMember", event.data, client, false);
+                if (event.clear) {
+                    for (const remove of event.clear) {
+                        switch (remove) {
+                            case "Nickname":
+                                changes["nickname"] = undefined;
+                                break;
+                            case "Avatar":
+                                changes["avatar"] = undefined;
+                                break;
+                            case "Roles":
+                                changes["roles"] = [];
+                                break;
+                            case "Timeout":
+                                changes["timeout"] = undefined;
+                                break;
+                        }
+                    }
+                }
+                client.serverMembers.updateUnderlyingObject(event.id.server + event.id.user, changes);
+                client.emit("serverMemberUpdate", member, previousMember);
+            }
+            break;
+        }
+        case "ServerMemberLeave": {
+            if (event.user) {
+                handleEvent(client, {
+                    type: "ServerDelete",
+                    id: event.id,
+                }, setReady);
+                return;
+            }
+            const id = {
+                server: event.id,
+                user: event.user,
+            };
+            if (client.serverMembers.getOrPartial(id)) {
+                const member = client.serverMembers.getUnderlyingObject(id.server + id.user);
+                client.emit("serverMemberLeave", member);
+                client.serverMembers.delete(id.server + id.user);
+            }
+            break;
+        }
+        case "UserUpdate": {
+            const user = client.users.getOrPartial(event.id);
+            if (user) {
+                const previousUser = {
+                    ...client.users.getUnderlyingObject(event.id),
+                };
+                const changes = hydrate("user", event.data, client, false);
+                if (event.clear) {
+                    for (const remove of event.clear) {
+                        switch (remove) {
+                            case "Avatar":
+                                changes["avatar"] = undefined;
+                                break;
+                            case "StatusPresence":
+                                changes["status"] = {
+                                    ...(previousUser.status ?? {}),
+                                    ...(changes["status"] ?? {}),
+                                    presence: undefined,
+                                };
+                                break;
+                            case "StatusText":
+                                changes["status"] = {
+                                    ...(previousUser.status ?? {}),
+                                    ...(changes["status"] ?? {}),
+                                    text: undefined,
+                                };
+                                break;
+                        }
+                    }
+                }
+                client.users.updateUnderlyingObject(event.id, changes);
+                client.emit("userUpdate", user, previousUser);
+            }
+            break;
+        }
+        case "UserRelationship": {
+            handleEvent(client, {
+                type: "UserUpdate",
+                id: event.user._id,
+                data: {
+                    relationship: event.user.relationship,
+                },
+            }, setReady);
+            break;
+        }
+        case "UserPresence": {
+            handleEvent(client, {
+                type: "UserUpdate",
+                id: event.id,
+                data: {
+                    online: event.online,
+                },
+            }, setReady);
+            break;
+        }
+        case "UserSettingsUpdate": {
+            client.emit("userSettingsUpdate", event.id, event.update);
+            break;
+        }
+        case "UserPlatformWipe": {
+            batch(() => {
+                handleEvent(client, {
+                    type: "BulkMessageDelete",
+                    channel: "0",
+                    ids: client.messages
+                        .toList()
+                        .filter((message) => message.authorId === event.user_id)
+                        .map((message) => message.id),
+                }, setReady);
+                handleEvent(client, {
+                    type: "UserUpdate",
+                    id: event.user_id,
+                    data: {
+                        username: `Deleted User`,
+                        online: false,
+                        flags: event.flags,
+                        badges: 0,
+                        relationship: "None",
+                    },
+                    clear: ["Avatar", "StatusPresence", "StatusText"],
+                }, setReady);
+            });
+            break;
+        }
+        case "EmojiCreate": {
+            if (!client.emojis.has(event._id)) {
+                client.emojis.getOrCreate(event._id, event, true);
+            }
+            break;
+        }
+        case "EmojiDelete": {
+            if (client.emojis.getOrPartial(event.id)) {
+                const emoji = client.emojis.getUnderlyingObject(event.id);
+                client.emit("emojiDelete", emoji);
+                client.emojis.delete(event.id);
+            }
+            break;
+        }
+        case "Auth": {
+            // TODO: implement DeleteSession and DeleteAllSessions
+            break;
+        }
+    }
+}

package/lib/esm/hydration/bot.d.ts

@@ -0,0 +1,21 @@
+import { Bot as ApiBot } from "../api";
+import { Hydrate } from "./index";
+export type HydratedBot = {
+    id: string;
+    ownerId: string;
+    token: string;
+    public: boolean;
+    analytics: boolean;
+    discoverable: boolean;
+    interactionsUrl?: string;
+    termsOfServiceUrl?: string;
+    privacyPolicyUrl?: string;
+    flags: BotFlags;
+};
+export declare const botHydration: Hydrate<ApiBot, HydratedBot>;
+/**
+ * Flags attributed to users
+ */
+export declare enum BotFlags {
+}
+//# sourceMappingURL=bot.d.ts.map

package/lib/esm/hydration/bot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../../../src/hydration/bot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,IAAI,MAAM,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,QAAQ,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,MAAM,EAAE,WAAW,CAqBrD,CAAC;AAEF;;GAEG;AACH,oBAAY,QAAQ;CAAG"}

package/lib/esm/hydration/bot.js

@@ -0,0 +1,28 @@
+export const botHydration = {
+    keyMapping: {
+        _id: "id",
+        owner: "ownerId",
+        interactions_url: "interactionsUrl",
+        terms_of_service_url: "termsOfServiceUrl",
+        privacy_policy_url: "privacyPolicyUrl",
+    },
+    functions: {
+        id: (bot) => bot._id,
+        ownerId: (bot) => bot.owner,
+        token: (bot) => bot.token,
+        public: (bot) => bot.public,
+        analytics: (bot) => bot.analytics,
+        discoverable: (bot) => bot.discoverable,
+        interactionsUrl: (bot) => bot.interactions_url,
+        termsOfServiceUrl: (bot) => bot.terms_of_service_url,
+        privacyPolicyUrl: (bot) => bot.privacy_policy_url,
+        flags: (bot) => bot.flags,
+    },
+    initialHydration: () => ({}),
+};
+/**
+ * Flags attributed to users
+ */
+export var BotFlags;
+(function (BotFlags) {
+})(BotFlags || (BotFlags = {}));

package/lib/esm/hydration/channel.d.ts

@@ -0,0 +1,25 @@
+import { Channel as ApiChannel, OverrideField } from "../api";
+import { File } from "../index.js";
+import type { Merge } from "../lib/merge.js";
+import { Hydrate } from "./index.js";
+import { ReactiveSet } from "@solid-primitives/set";
+export type HydratedChannel = {
+    id: string;
+    channelType: ApiChannel["channel_type"];
+    name: string;
+    description?: string;
+    icon?: File;
+    active: boolean;
+    typingIds: ReactiveSet<string>;
+    recipientIds: ReactiveSet<string>;
+    userId?: string;
+    ownerId?: string;
+    serverId?: string;
+    permissions?: number;
+    defaultPermissions?: OverrideField;
+    rolePermissions?: Record<string, OverrideField>;
+    nsfw: boolean;
+    lastMessageId?: string;
+};
+export declare const channelHydration: Hydrate<Merge<ApiChannel>, HydratedChannel>;
+//# sourceMappingURL=channel.d.ts.map

package/lib/esm/hydration/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../../src/hydration/channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC9D,OAAO,EAAU,IAAI,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,UAAU,CAAC,cAAc,CAAC,CAAC;IAExC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,IAAI,CAAC;IAEZ,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/B,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAElC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,aAAa,CAAC;IACnC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAChD,IAAI,EAAE,OAAO,CAAC;IAEd,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,eAAe,CAkCxE,CAAC"}

package/lib/esm/hydration/channel.js

@@ -0,0 +1,37 @@
+import { File } from "../index.js";
+import { ReactiveSet } from "@solid-primitives/set";
+export const channelHydration = {
+    keyMapping: {
+        _id: "id",
+        channel_type: "channelType",
+        recipients: "recipientIds",
+        user: "userId",
+        owner: "ownerId",
+        server: "serverId",
+        default_permissions: "defaultPermissions",
+        role_permissions: "rolePermissions",
+        last_message_id: "lastMessageId",
+    },
+    functions: {
+        id: (channel) => channel._id,
+        channelType: (channel) => channel.channel_type,
+        name: (channel) => channel.name,
+        description: (channel) => channel.description,
+        icon: (channel, ctx) => new File(ctx, channel.icon),
+        active: (channel) => channel.active || false,
+        typingIds: () => new ReactiveSet(),
+        recipientIds: (channel) => new ReactiveSet(channel.recipients),
+        userId: (channel) => channel.user,
+        ownerId: (channel) => channel.owner,
+        serverId: (channel) => channel.server,
+        permissions: (channel) => channel.permissions,
+        defaultPermissions: (channel) => channel.default_permissions,
+        rolePermissions: (channel) => channel.role_permissions,
+        nsfw: (channel) => channel.nsfw || false,
+        lastMessageId: (channel) => channel.last_message_id,
+    },
+    initialHydration: () => ({
+        typingIds: new ReactiveSet(),
+        recipientIds: new ReactiveSet(),
+    }),
+};

package/lib/esm/hydration/channelUnread.d.ts

@@ -0,0 +1,11 @@
+import { API } from "../index.js";
+import type { Merge } from "../lib/merge.js";
+import { Hydrate } from "./index.js";
+import { ReactiveSet } from "@solid-primitives/set";
+export type HydratedChannelUnread = {
+    id: string;
+    lastMessageId?: string;
+    messageMentionIds: ReactiveSet<string>;
+};
+export declare const channelUnreadHydration: Hydrate<Merge<API.ChannelUnread>, HydratedChannelUnread>;
+//# sourceMappingURL=channelUnread.d.ts.map

package/lib/esm/hydration/channelUnread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channelUnread.d.ts","sourceRoot":"","sources":["../../../src/hydration/channelUnread.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACxC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,OAAO,CAC1C,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,EACxB,qBAAqB,CAetB,CAAC"}

package/lib/esm/hydration/channelUnread.js

@@ -0,0 +1,16 @@
+import { ReactiveSet } from "@solid-primitives/set";
+export const channelUnreadHydration = {
+    keyMapping: {
+        _id: "id",
+        last_id: "lastMessageId",
+        mentions: "messageMentionIds",
+    },
+    functions: {
+        id: (unread) => unread._id.channel,
+        lastMessageId: (unread) => unread.last_id,
+        messageMentionIds: (unread) => new ReactiveSet(unread.mentions),
+    },
+    initialHydration: () => ({
+        messageMentionIds: new ReactiveSet(),
+    }),
+};

package/lib/esm/hydration/channelWebhook.d.ts

@@ -0,0 +1,12 @@
+import { API, File } from "../index.js";
+import type { Merge } from "../lib/merge.js";
+import { Hydrate } from "./index.js";
+export type HydratedChannelWebhook = {
+    id: string;
+    name: string;
+    avatar?: File;
+    channelId: string;
+    token: string;
+};
+export declare const channelWebhookHydration: Hydrate<Merge<API.Webhook>, HydratedChannelWebhook>;
+//# sourceMappingURL=channelWebhook.d.ts.map