hischool.js 0.0.1

package/lib/cjs/events/v1.js

@@ -0,0 +1,502 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEvent = void 0;
+const index_js_1 = require("../hydration/index.js");
+const set_1 = require("@solid-primitives/set");
+const solid_js_1 = require("solid-js");
+/**
+ * Handle an event for the Client
+ * @param client Client
+ * @param event Event
+ * @param setReady Signal state change
+ */
+function handleEvent(client, event, setReady) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        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": {
+                (0, solid_js_1.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) {
+                    yield 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) {
+                        yield client.users.fetch(event.author);
+                        const serverId = (_a = client.channels.get(event.channel)) === null || _a === void 0 ? void 0 : _a.serverId;
+                        if (serverId)
+                            yield client.serverMembers.fetch(serverId, event.author);
+                    }
+                    (0, solid_js_1.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 = Object.assign(Object.assign({}, client.messages.getUnderlyingObject(event.id)), { channelId: event.channel });
+                    client.messages.updateUnderlyingObject(event.id, Object.assign(Object.assign({}, (0, index_js_1.hydrate)("message", Object.assign(Object.assign({}, 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 = Object.assign(Object.assign({}, client.messages.getUnderlyingObject(event.id)), { channelId: event.channel });
+                    client.messages.updateUnderlyingObject(event.id, "embeds", (embeds) => { var _a; return [...(embeds !== null && embeds !== void 0 ? embeds : []), (_a = event.append.embeds) !== null && _a !== void 0 ? _a : []]; });
+                    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": {
+                (0, solid_js_1.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 set_1.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 === null || set === void 0 ? void 0 : 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 = Object.assign({}, client.channels.getUnderlyingObject(event.id));
+                    const changes = (0, index_js_1.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, yield 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)) {
+                    (0, solid_js_1.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 = Object.assign({}, client.servers.getUnderlyingObject(event.id));
+                    const changes = (0, index_js_1.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 = (_b = server.roles.get(event.role_id)) !== null && _b !== void 0 ? _b : {};
+                    server.roles.set(event.role_id, Object.assign(Object.assign({}, 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) {
+                            yield 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 = Object.assign({}, client.serverMembers.getUnderlyingObject(event.id.server + event.id.user));
+                    const changes = (0, index_js_1.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 = Object.assign({}, client.users.getUnderlyingObject(event.id));
+                    const changes = (0, index_js_1.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"] = Object.assign(Object.assign(Object.assign({}, ((_c = previousUser.status) !== null && _c !== void 0 ? _c : {})), ((_d = changes["status"]) !== null && _d !== void 0 ? _d : {})), { presence: undefined });
+                                    break;
+                                case "StatusText":
+                                    changes["status"] = Object.assign(Object.assign(Object.assign({}, ((_e = previousUser.status) !== null && _e !== void 0 ? _e : {})), ((_f = changes["status"]) !== null && _f !== void 0 ? _f : {})), { 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": {
+                (0, solid_js_1.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;
+            }
+        }
+    });
+}
+exports.handleEvent = handleEvent;

package/lib/cjs/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/cjs/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/cjs/hydration/bot.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotFlags = exports.botHydration = void 0;
+exports.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
+ */
+var BotFlags;
+(function (BotFlags) {
+})(BotFlags || (exports.BotFlags = BotFlags = {}));

package/lib/cjs/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/cjs/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/cjs/hydration/channel.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelHydration = void 0;
+const index_js_1 = require("../index.js");
+const set_1 = require("@solid-primitives/set");
+exports.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 index_js_1.File(ctx, channel.icon),
+        active: (channel) => channel.active || false,
+        typingIds: () => new set_1.ReactiveSet(),
+        recipientIds: (channel) => new set_1.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 set_1.ReactiveSet(),
+        recipientIds: new set_1.ReactiveSet(),
+    }),
+};

package/lib/cjs/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/cjs/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/cjs/hydration/channelUnread.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelUnreadHydration = void 0;
+const set_1 = require("@solid-primitives/set");
+exports.channelUnreadHydration = {
+    keyMapping: {
+        _id: "id",
+        last_id: "lastMessageId",
+        mentions: "messageMentionIds",
+    },
+    functions: {
+        id: (unread) => unread._id.channel,
+        lastMessageId: (unread) => unread.last_id,
+        messageMentionIds: (unread) => new set_1.ReactiveSet(unread.mentions),
+    },
+    initialHydration: () => ({
+        messageMentionIds: new set_1.ReactiveSet(),
+    }),
+};