@pubby/sdk/dist/esm/modules/room/index.js

Pubby Development Kit

import { __extends, __assign, __awaiter, __generator, __read, __spread } from 'tslib';
import '../../lib/streams/index.js';
import { PubbyModule } from '../../module.js';
import '../../websocket/incoming/index.js';
import '../../websocket/outgoing/index.js';
import { WebsocketModule } from '../../websocket/websocket.js';
import { ApiModule } from '../api/index.js';
import { PubbyStream } from '../../lib/streams/lib/stream.js';
import { UserSetResponse } from '../../websocket/incoming/user-set.event.js';
import { UserLeaveResponse } from '../../websocket/incoming/user-leave.event.js';
import { RoomUpdateResponse } from '../../websocket/incoming/room-update.event.js';
import { QueueUpdateResponse } from '../../websocket/incoming/queue-update.event.js';
import { UserJoinRequest } from '../../websocket/outgoing/user-join.event.js';

var RoomModule = /** @class */ (function (_super) {
    __extends(RoomModule, _super);
    function RoomModule(client) {
        var _this = _super.call(this, client) || this;
        _this.state$ = new PubbyStream();
        // Importa websocket
        client.use(WebsocketModule);
        // Importa API
        client.use(ApiModule);
        client.room = _this;
        _this.userUpdate$ = client.ws.listen(UserSetResponse);
        _this.userLeave$ = client.ws.listen(UserLeaveResponse);
        _this.roomUpdate$ = client.ws.listen(RoomUpdateResponse);
        return _this;
    }
    Object.defineProperty(RoomModule.prototype, "state", {
        get: function () {
            var _a;
            return ((_a = this.state$.value) !== null && _a !== void 0 ? _a : {
                room: null,
                users: new Map(),
                usersRoles: new Map(),
            });
        },
        enumerable: false,
        configurable: true
    });
    RoomModule.prototype.init = function () {
        var _this = this;
        // Listen room updates
        this.roomUpdate$.subscribe(function (_a) {
            var room = _a.room;
            _this.state$.add(__assign(__assign({}, _this.state), { room: room }));
        });
        // Listen fot user join and user updates
        this.userUpdate$.subscribe(function (_a) {
            var user = _a.user;
            var old = _this.state.users.get(user.id);
            _this.state.users.set(user.id, user);
            if (old) {
                _this.emit("user-update", user, old);
            }
            else {
                _this.emit("user-join", user);
            }
        });
        // Listen for user leave
        this.userLeave$.subscribe(function (_a) {
            var userId = _a.userId;
            var user = __assign({}, _this.state.users.get(userId));
            _this.state.users.delete(userId);
            _this.emit("user-leave", user);
        });
    };
    RoomModule.prototype.join = function (slug, password) {
        var _a;
        return __awaiter(this, void 0, void 0, function () {
            var room, _b, actions, playback, queue, users, usersRoles;
            return __generator(this, function (_c) {
                switch (_c.label) {
                    case 0:
                        if (((_a = this.state.room) === null || _a === void 0 ? void 0 : _a.slug) === slug) {
                            return [2 /*return*/];
                        }
                        return [4 /*yield*/, this.pubby.api.room.findOne(slug)];
                    case 1:
                        room = _c.sent();
                        if (room.visibility === "password" && !password) {
                            throw new Error("Room password required!");
                        }
                        return [4 /*yield*/, this.pubby.ws.addAsync(new UserJoinRequest(slug, password))];
                    case 2:
                        _c.sent();
                        return [4 /*yield*/, this.pubby.api.room.getCurrent()];
                    case 3:
                        _b = _c.sent(), actions = _b.actions, playback = _b.playback, queue = _b.queue, users = _b.users, usersRoles = _b.usersRoles;
                        // Update playback
                        if (this.pubby.has("playback")) {
                            this.pubby.playback.state = playback;
                            this.pubby.playback.actions = {
                                adds: new Set(actions.adds),
                                likes: new Set(actions.likes),
                                dislikes: new Set(actions.dislikes),
                            };
                        }
                        // Update queue
                        if (this.pubby.has("queue")) {
                            this.pubby.queue.state = new Set(queue);
                            this.pubby.queue.update$.add(new QueueUpdateResponse(Array.from(this.pubby.queue.state)));
                        }
                        this.state$.add({
                            room: room,
                            users: new Map(Object.entries(users)),
                            usersRoles: new Map(Object.entries(usersRoles).map(function (_a) {
                                var _b = __read(_a, 2), key = _b[0], value = _b[1];
                                return [key, new Set(value)];
                            })),
                        });
                        this.emit("load", this.state);
                        return [2 /*return*/];
                }
            });
        });
    };
    RoomModule.prototype.on = function (event) {
        var args = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            args[_i - 1] = arguments[_i];
        }
        return _super.prototype.on.apply(this, __spread([event], args));
    };
    return RoomModule;
}(PubbyModule));

export { RoomModule };