openplugdj 1.0.0 → 1.0.1

package/dist/adapters/MemoryStore.d.ts

@@ -0,0 +1,10 @@
+import { Store } from "./Store";
+export declare class MemoryStore<T> implements Store<T> {
+    private map;
+    get(id: string): Promise<T | undefined>;
+    set(id: string, value: T): Promise<void>;
+    delete(id: string): Promise<void>;
+    getAll(): Promise<T[]>;
+    has(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/dist/adapters/MemoryStore.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStore = void 0;
+class MemoryStore {
+    constructor() {
+        this.map = new Map();
+    }
+    async get(id) {
+        return this.map.get(id);
+    }
+    async set(id, value) {
+        this.map.set(id, value);
+    }
+    async delete(id) {
+        this.map.delete(id);
+    }
+    async getAll() {
+        return Array.from(this.map.values());
+    }
+    async has(id) {
+        return this.map.has(id);
+    }
+    async clear() {
+        this.map.clear();
+    }
+}
+exports.MemoryStore = MemoryStore;

package/dist/adapters/RedisStore.d.ts

@@ -0,0 +1,13 @@
+import { Store } from "./Store";
+export declare class RedisStore<T> implements Store<T> {
+    private redis;
+    private namespace;
+    constructor(redisUrl: string, namespace: string);
+    private key;
+    get(id: string): Promise<T | undefined>;
+    set(id: string, value: T): Promise<void>;
+    delete(id: string): Promise<void>;
+    getAll(): Promise<T[]>;
+    has(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/dist/adapters/RedisStore.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStore = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisStore {
+    constructor(redisUrl, namespace) {
+        this.redis = new ioredis_1.default(redisUrl);
+        this.namespace = namespace;
+    }
+    key(id) {
+        return `${this.namespace}:${id}`;
+    }
+    async get(id) {
+        const data = await this.redis.get(this.key(id));
+        if (!data)
+            return undefined;
+        return JSON.parse(data);
+    }
+    async set(id, value) {
+        await this.redis.set(this.key(id), JSON.stringify(value));
+    }
+    async delete(id) {
+        await this.redis.del(this.key(id));
+    }
+    async getAll() {
+        const keys = await this.redis.keys(`${this.namespace}:*`);
+        if (!keys.length)
+            return [];
+        const values = await this.redis.mget(...keys);
+        return values
+            .filter(Boolean)
+            .map(v => JSON.parse(v));
+    }
+    async has(id) {
+        const exists = await this.redis.exists(this.key(id));
+        return exists === 1;
+    }
+    async clear() {
+        const keys = await this.redis.keys(`${this.namespace}:*`);
+        if (keys.length) {
+            await this.redis.del(...keys);
+        }
+    }
+}
+exports.RedisStore = RedisStore;

package/dist/adapters/Store.d.ts

@@ -0,0 +1,8 @@
+export interface Store<T> {
+    get(id: string): Promise<T | undefined>;
+    set(id: string, value: T): Promise<void>;
+    delete(id: string): Promise<void>;
+    getAll(): Promise<T[]>;
+    has(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/dist/adapters/Store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/DJ.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from "events";
+import { Room } from "./Room";
+import { StreamService } from "../services/StreamService";
+export declare class DJ extends EventEmitter {
+    private streamService;
+    private rooms;
+    constructor(streamService: StreamService);
+    createRoom(id: string): Room;
+    getRoom(id: string): Promise<Room | undefined>;
+    deleteRoom(id: string): void;
+}

package/dist/core/DJ.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DJ = void 0;
+const events_1 = require("events");
+const Room_1 = require("./Room");
+const MemoryStore_1 = require("../adapters/MemoryStore");
+class DJ extends events_1.EventEmitter {
+    constructor(streamService) {
+        super();
+        this.streamService = streamService;
+        this.rooms = new MemoryStore_1.MemoryStore();
+    }
+    createRoom(id) {
+        const room = new Room_1.Room(id, this.streamService);
+        this.rooms.set(id, room);
+        this.emit("roomCreated", room);
+        return room;
+    }
+    getRoom(id) {
+        return this.rooms.get(id);
+    }
+    deleteRoom(id) {
+        const room = this.rooms.get(id);
+        if (!room)
+            return;
+        this.rooms.delete(id);
+        this.emit("roomDeleted", room);
+    }
+}
+exports.DJ = DJ;

package/dist/core/Player.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from "events";
+import { Queue } from "./Queue";
+import { StreamService } from "../services/StreamService";
+import { DJEntry } from "../models/DJEntry";
+export declare class Player extends EventEmitter {
+    private queue;
+    private streamService;
+    private current;
+    private voteService;
+    private playing;
+    constructor(queue: Queue, streamService: StreamService);
+    playNext(): Promise<void>;
+    vote(userId: string, type: "up" | "down"): void;
+    skip(): void;
+    getCurrent(): DJEntry | null;
+}

package/dist/core/Player.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = void 0;
+const events_1 = require("events");
+const VoteService_1 = require("../services/VoteService");
+class Player extends events_1.EventEmitter {
+    constructor(queue, streamService) {
+        super();
+        this.queue = queue;
+        this.streamService = streamService;
+        this.current = null;
+        this.voteService = new VoteService_1.VoteService();
+        this.playing = false;
+    }
+    async playNext() {
+        if (this.playing)
+            return;
+        const entry = this.queue.next();
+        if (!entry) {
+            this.emit("queueEmpty");
+            return;
+        }
+        this.current = entry;
+        this.voteService.clear();
+        this.playing = true;
+        this.emit("trackStart", entry.track);
+        await this.streamService.play(entry.track);
+        this.emit("trackEnd", entry.track);
+        this.playing = false;
+        this.playNext();
+    }
+    vote(userId, type) {
+        this.voteService.vote(userId, type);
+        this.emit("voteUpdated", this.voteService.getResults());
+    }
+    skip() {
+        this.streamService.stop();
+        this.playing = false;
+        this.playNext();
+    }
+    getCurrent() {
+        return this.current;
+    }
+}
+exports.Player = Player;

package/dist/core/Queue.d.ts

@@ -0,0 +1,11 @@
+import { DJEntry } from "../models/DJEntry";
+export declare class Queue {
+    private entries;
+    add(entry: DJEntry): void;
+    next(): DJEntry | undefined;
+    remove(entryId: string): void;
+    reorder(from: number, to: number): void;
+    getAll(): DJEntry[];
+    size(): number;
+    clear(): void;
+}

package/dist/core/Queue.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue {
+    constructor() {
+        this.entries = [];
+    }
+    add(entry) {
+        this.entries.push(entry);
+    }
+    next() {
+        return this.entries.shift();
+    }
+    remove(entryId) {
+        this.entries = this.entries.filter(e => e.id !== entryId);
+    }
+    reorder(from, to) {
+        const [item] = this.entries.splice(from, 1);
+        this.entries.splice(to, 0, item);
+    }
+    getAll() {
+        return [...this.entries];
+    }
+    size() {
+        return this.entries.length;
+    }
+    clear() {
+        this.entries = [];
+    }
+}
+exports.Queue = Queue;

package/dist/core/Room.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from "events";
+import { Queue } from "./Queue";
+import { Player } from "./Player";
+import { User } from "../models/User";
+import { DJEntry } from "../models/DJEntry";
+import { StreamService } from "../services/StreamService";
+export declare class Room extends EventEmitter {
+    id: string;
+    private users;
+    queue: Queue;
+    player: Player;
+    constructor(id: string, streamService: StreamService);
+    addUser(user: User): void;
+    removeUser(userId: string): void;
+    addEntry(entry: DJEntry): void;
+    start(): void;
+}

package/dist/core/Room.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = void 0;
+const events_1 = require("events");
+const Queue_1 = require("./Queue");
+const Player_1 = require("./Player");
+class Room extends events_1.EventEmitter {
+    constructor(id, streamService) {
+        super();
+        this.id = id;
+        this.users = new Map();
+        this.queue = new Queue_1.Queue();
+        this.player = new Player_1.Player(this.queue, streamService);
+        this.player.on("trackStart", t => this.emit("trackStart", t));
+        this.player.on("trackEnd", t => this.emit("trackEnd", t));
+        this.player.on("voteUpdated", v => this.emit("voteUpdated", v));
+        this.player.on("queueEmpty", () => this.emit("queueEmpty"));
+    }
+    addUser(user) {
+        this.users.set(user.id, user);
+        this.emit("userJoined", user);
+    }
+    removeUser(userId) {
+        const user = this.users.get(userId);
+        if (!user)
+            return;
+        this.users.delete(userId);
+        this.emit("userLeft", user);
+    }
+    addEntry(entry) {
+        this.queue.add(entry);
+        this.emit("queueUpdated", this.queue.getAll());
+    }
+    start() {
+        this.player.playNext();
+    }
+}
+exports.Room = Room;

package/dist/events/EventTypes.d.ts

@@ -0,0 +1,15 @@
+import { Track } from "../models/Track";
+import { DJEntry } from "../models/DJEntry";
+import { User } from "../models/User";
+export interface RoomEvents {
+    userJoined: (user: User) => void;
+    userLeft: (user: User) => void;
+    trackStart: (track: Track) => void;
+    trackEnd: (track: Track) => void;
+    queueUpdated: (entries: DJEntry[]) => void;
+    voteUpdated: (votes: {
+        up: number;
+        down: number;
+    }) => void;
+    queueEmpty: () => void;
+}

package/dist/events/EventTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { DJ } from "./core/DJ";
+export { Room } from "./core/Room";
+export { Player } from "./core/Player";
+export { Queue } from "./core/Queue";
+export * from "./models/Track";
+export * from "./models/User";
+export * from "./models/DJEntry";
+export * from "./services/StreamService";
+export * from "./services/MetadataService";
+export * from "./adapters/MemoryStore";
+export * from "./adapters/RedisStore";
+export * from "./utils/time";

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = exports.Player = exports.Room = exports.DJ = void 0;
+var DJ_1 = require("./core/DJ");
+Object.defineProperty(exports, "DJ", { enumerable: true, get: function () { return DJ_1.DJ; } });
+var Room_1 = require("./core/Room");
+Object.defineProperty(exports, "Room", { enumerable: true, get: function () { return Room_1.Room; } });
+var Player_1 = require("./core/Player");
+Object.defineProperty(exports, "Player", { enumerable: true, get: function () { return Player_1.Player; } });
+var Queue_1 = require("./core/Queue");
+Object.defineProperty(exports, "Queue", { enumerable: true, get: function () { return Queue_1.Queue; } });
+__exportStar(require("./models/Track"), exports);
+__exportStar(require("./models/User"), exports);
+__exportStar(require("./models/DJEntry"), exports);
+__exportStar(require("./services/StreamService"), exports);
+__exportStar(require("./services/MetadataService"), exports);
+__exportStar(require("./adapters/MemoryStore"), exports);
+__exportStar(require("./adapters/RedisStore"), exports);
+__exportStar(require("./utils/time"), exports);

package/dist/models/DJEntry.d.ts

@@ -0,0 +1,8 @@
+import { Track } from "./Track";
+export interface DJEntry {
+    id: string;
+    track: Track;
+    userId: string;
+    position: number;
+    createdAt: number;
+}

package/dist/models/DJEntry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Track.d.ts

@@ -0,0 +1,8 @@
+export interface Track {
+    id: string;
+    title: string;
+    url: string;
+    duration: number;
+    addedBy: string;
+    createdAt: number;
+}

package/dist/models/Track.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/User.d.ts

@@ -0,0 +1,7 @@
+export type UserRole = "listener" | "dj" | "admin";
+export interface User {
+    id: string;
+    username: string;
+    role: UserRole;
+    joinedAt: number;
+}

package/dist/models/User.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/MetadataService.d.ts

@@ -0,0 +1,4 @@
+import { Track } from "../models/Track";
+export interface MetadataService {
+    resolve(url: string): Promise<Partial<Track>>;
+}

package/dist/services/MetadataService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/StreamService.d.ts

@@ -0,0 +1,5 @@
+import { Track } from "../models/Track";
+export interface StreamService {
+    play(track: Track): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/services/StreamService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/VoteService.d.ts

@@ -0,0 +1,10 @@
+export declare class VoteService {
+    private votes;
+    vote(userId: string, type: "up" | "down"): void;
+    clear(): void;
+    getResults(): {
+        up: number;
+        down: number;
+        total: number;
+    };
+}

package/dist/services/VoteService.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoteService = void 0;
+class VoteService {
+    constructor() {
+        this.votes = new Map();
+    }
+    vote(userId, type) {
+        this.votes.set(userId, type);
+    }
+    clear() {
+        this.votes.clear();
+    }
+    getResults() {
+        let up = 0;
+        let down = 0;
+        for (const v of this.votes.values()) {
+            if (v === "up")
+                up++;
+            if (v === "down")
+                down++;
+        }
+        return { up, down, total: up - down };
+    }
+}
+exports.VoteService = VoteService;

package/dist/utils/time.d.ts

@@ -0,0 +1,4 @@
+export declare function now(): number;
+export declare function seconds(seconds: number): number;
+export declare function minutes(minutes: number): number;
+export declare function calculateRemaining(startTime: number, duration: number): number;

package/dist/utils/time.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.now = now;
+exports.seconds = seconds;
+exports.minutes = minutes;
+exports.calculateRemaining = calculateRemaining;
+function now() {
+    return Date.now();
+}
+function seconds(seconds) {
+    return seconds * 1000;
+}
+function minutes(minutes) {
+    return minutes * 60 * 1000;
+}
+function calculateRemaining(startTime, duration) {
+    const elapsed = now() - startTime;
+    const remaining = duration - elapsed;
+    return remaining > 0 ? remaining : 0;
+}

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "openplugdj",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A lightweight DJ queue and room engine inspired by plug.dj",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": ["dist", "README.md", "LICENSE", "package.json"],
   "scripts": {
     "build": "tsc",
-    "dev": "tsc -w"
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build"
   },
   "keywords": ["dj", "queue", "music", "room", "realtime"],
   "author": "bulondra",
@@ -19,4 +24,4 @@
     "typescript": "^5.5.3"
   },
   "private": false
-}
+}