Queue and Storage

import type { Player, Track } from 'hoshimi';

declare const player: Player;
declare const track: Track;

const queue = player.queue;

if (queue.isEmpty()) {
  // nothing queued yet
}

await queue.add(track);
const next = await queue.shift();

console.log(queue.size);
console.log(queue.totalSize);
console.log(queue.current);
console.log(queue.history.length);

await queue.shuffle();
await queue.splice(0, 1);
await queue.clear();

import { PlayerMemoryStorage, QueueMemoryStorage } from 'hoshimi';

const playerStorage = new PlayerMemoryStorage();
const queueStorage = new QueueMemoryStorage();

playerStorage.namespace = 'hoshimiplayer';
queueStorage.namespace = 'hoshimiqueue';

import type { QueueJson, RestOrArray } from 'hoshimi';
import { QueueStorageAdapter } from 'hoshimi';

interface RedisLike {
  get(key: string): Promise<string | null>;
  set(key: string, value: string): Promise<void>;
  del(key: string): Promise<number>;
  exists(key: string): Promise<number>;
}

class RedisStorage extends QueueStorageAdapter {
  constructor(private readonly redis: RedisLike) {
    super();
  }

  override async get(key: string): Promise<QueueJson | undefined> {
    const value = await this.redis.get(this.buildKey(this.namespace, key));
    return value ? this.parse(value) : undefined;
  }

  override async set(key: string, value: QueueJson): Promise<void> {
    await this.redis.set(this.buildKey(this.namespace, key), this.stringify(value));
  }

  override async delete(key: string): Promise<boolean> {
    return (await this.redis.del(this.buildKey(this.namespace, key))) > 0;
  }

  override async has(key: string): Promise<boolean> {
    return (await this.redis.exists(this.buildKey(this.namespace, key))) > 0;
  }

  override async clear(): Promise<void> {
    // implement according to your redis strategy
  }

  override parse(value: unknown): QueueJson {
    return typeof value === "string" ? JSON.parse(value) : (value as QueueJson);
  }

  override stringify<R = string>(value: unknown): R {
    return (typeof value === "object" ? JSON.stringify(value) : value) as R;
  }

  public buildKey(...parts: RestOrArray<string>): string {
    const flattern = parts.flat();
    return flattern.join(":");
  }
}