kazagumo-bun 3.4.0-b

package/src/Managers/Supports/KazagumoTrack.ts

@@ -0,0 +1,211 @@
+import { Kazagumo } from '../../Kazagumo';
+import {
+  escapeRegExp,
+  Events,
+  KazagumoError,
+  RawTrack,
+  ResolveOptions,
+  SourceIDs,
+  SupportedSources,
+} from '../../Modules/Interfaces';
+import { Track } from 'shoukaku';
+import { KazagumoPlayer } from '../KazagumoPlayer';
+
+export class KazagumoTrack {
+  /**
+   * Kazagumo Instance
+   */
+  public kazagumo: Kazagumo | undefined;
+  /**
+   * Track Requester
+   */
+  public requester: unknown | undefined;
+
+  /** Track's Base64 */
+  public track: string;
+  /** Track's source */
+  public sourceName: string;
+  /** Track's title */
+  public title: string;
+  /** Track's URI */
+  public uri?: string;
+  /** Track's identifier */
+  public identifier: string;
+  /** Whether the track is seekable */
+  public isSeekable: boolean;
+  /** Whether the track is a stream */
+  public isStream: boolean;
+  /** Track's author */
+  public author: string | undefined;
+  /** Track's length */
+  public length: number | undefined;
+  /** Track's position (I don't know this) */
+  public position: number | undefined;
+  /** Track's thumbnail, if available */
+  public thumbnail: string | undefined;
+  /** The YouTube/soundcloud URI for spotify and other unsupported source */
+  public realUri?: string;
+
+  public resolvedBySource: boolean = false;
+
+  constructor(
+    private readonly raw: Track,
+    requester: unknown,
+  ) {
+    this.kazagumo = undefined;
+
+    this.track = raw.encoded;
+    this.sourceName = raw.info.sourceName;
+    this.title = raw.info.title;
+    this.uri = raw.info.uri;
+    this.identifier = raw.info.identifier;
+    this.isSeekable = raw.info.isSeekable;
+    this.isStream = raw.info.isStream;
+    this.author = raw.info.author;
+    this.length = raw.info.length;
+    this.thumbnail = raw.info.artworkUrl;
+    this.realUri = SupportedSources.includes(this.sourceName) ? this.uri : undefined;
+
+    this.requester = requester;
+
+    if (this.sourceName === 'youtube' && this.identifier)
+      this.thumbnail = `https://img.youtube.com/vi/${this.identifier}/hqdefault.jpg`;
+  }
+
+  /**
+   * Get json of this track
+   * @returns {RawTrack}
+   */
+  public getRaw(): RawTrack {
+    return {
+      track: this.track,
+      info: {
+        title: this.title,
+        uri: this.uri,
+        identifier: this.identifier,
+        author: this.author,
+        sourceName: this.sourceName,
+        isSeekable: this.isSeekable,
+        isStream: this.isStream,
+        length: this.length,
+        position: this.position,
+        artworkUrl: this.thumbnail,
+      },
+      _raw: this.raw,
+    };
+  }
+
+  /**
+   * Set kazagumo instance
+   * @param kazagumo Kazagumo instance
+   * @returns KazagumoTrack
+   */
+  setKazagumo(kazagumo: Kazagumo): KazagumoTrack {
+    this.kazagumo = kazagumo;
+    if (this.sourceName === 'youtube' && this.identifier)
+      this.thumbnail = `https://img.youtube.com/vi/${this.identifier}/${
+        kazagumo.KazagumoOptions.defaultYoutubeThumbnail ?? 'hqdefault'
+      }.jpg`;
+
+    return this;
+  }
+
+  /**
+   * Whether the track is ready to play or need to be solved
+   */
+  get readyToPlay(): boolean {
+    return (
+      this.kazagumo !== undefined &&
+      !!this.track &&
+      !!this.sourceName &&
+      !!this.identifier &&
+      !!this.author &&
+      !!this.length &&
+      !!this.title &&
+      !!this.uri &&
+      !!this.realUri
+    );
+  }
+
+  /**
+   * Resolve the track
+   * @param options Resolve options
+   * @returns Promise<KazagumoTrack>
+   */
+  public async resolve(options?: ResolveOptions): Promise<KazagumoTrack> {
+    if (!this.kazagumo) throw new KazagumoError(1, 'Kazagumo is not set');
+    if (
+      this.kazagumo.KazagumoOptions.trackResolver &&
+      typeof this.kazagumo.KazagumoOptions.trackResolver === 'function' &&
+      (await this.kazagumo.KazagumoOptions.trackResolver.bind(this)(options))
+    )
+      return this;
+    const resolveSource = this.kazagumo.KazagumoOptions?.sourceForceResolve?.includes(this.sourceName);
+    const { forceResolve, overwrite } = options ? options : { forceResolve: false, overwrite: false };
+
+    if (!forceResolve && this.readyToPlay) return this;
+    if (resolveSource && this.resolvedBySource) return this;
+    if (resolveSource) {
+      this.resolvedBySource = true;
+      return this;
+    }
+
+    this.kazagumo.emit(Events.Debug, `Resolving ${this.sourceName} track ${this.title}; Source: ${this.sourceName}`);
+
+    const result = await this.getTrack(options?.player ?? null);
+    if (!result) throw new KazagumoError(2, 'No results found');
+
+    this.track = result.encoded;
+    this.realUri = result.info.uri;
+    this.length = result.info.length;
+
+    if (overwrite || resolveSource) {
+      this.title = result.info.title;
+      this.identifier = result.info.identifier;
+      this.isSeekable = result.info.isSeekable;
+      this.author = result.info.author;
+      this.length = result.info.length;
+      this.isStream = result.info.isStream;
+      this.uri = result.info.uri;
+    }
+    return this;
+  }
+
+  private async getTrack(player: KazagumoPlayer | null): Promise<Track> {
+    if (!this.kazagumo) throw new Error('Kazagumo is not set');
+
+    const defaultSearchEngine = this.kazagumo.KazagumoOptions.defaultSearchEngine;
+    const source = ((SourceIDs as any)[defaultSearchEngine || 'youtube'] || 'yt') + 'search:';
+    const query = [this.author, this.title].filter((x) => !!x).join(' - ');
+    const node = await this.kazagumo.getLeastUsedNode();
+
+    if (!node) throw new KazagumoError(1, 'No nodes available');
+
+    const result = player
+      ? await player.search(query, { source, requester: this.requester })
+      : await this.kazagumo.search(query, { engine: defaultSearchEngine, requester: this.requester });
+    if (!result || !result.tracks.length) throw new KazagumoError(2, 'No results found');
+
+    const rawTracks = result.tracks.map((x) => x.getRaw()._raw);
+
+    if (this.author) {
+      const author = [this.author, `${this.author} - Topic`];
+      const officialTrack = rawTracks.find(
+        (track) =>
+          author.some((name) => new RegExp(`^${escapeRegExp(name)}$`, 'i').test(track.info.author)) ||
+          new RegExp(`^${escapeRegExp(this.title)}$`, 'i').test(track.info.title),
+      );
+      if (officialTrack) return officialTrack;
+    }
+    if (this.length) {
+      const sameDuration = rawTracks.find(
+        (track) =>
+          track.info.length >= (this.length ? this.length : 0) - 2000 &&
+          track.info.length <= (this.length ? this.length : 0) + 2000,
+      );
+      if (sameDuration) return sameDuration;
+    }
+
+    return rawTracks[0];
+  }
+}

package/src/Modules/EventEmitter.ts

@@ -0,0 +1,53 @@
+type Listener = (...args: any[]) => void;
+
+export class EventEmitter {
+  private events: Map<string | symbol, Listener[]>;
+
+  constructor() {
+    this.events = new Map();
+  }
+
+  public on(event: string | symbol, listener: Listener): this {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event)!.push(listener);
+    return this;
+  }
+
+  public once(event: string | symbol, listener: Listener): this {
+    const onceWrapper = (...args: any[]) => {
+      this.off(event, onceWrapper);
+      listener.apply(this, args);
+    };
+    return this.on(event, onceWrapper);
+  }
+
+  public off(event: string | symbol, listener: Listener): this {
+    const listeners = this.events.get(event);
+    if (!listeners) return this;
+    const index = listeners.indexOf(listener);
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+    return this;
+  }
+
+  public emit(event: string | symbol, ...args: any[]): boolean {
+    const listeners = this.events.get(event);
+    if (!listeners || listeners.length === 0) return false;
+    
+    // Copy to avoid issues if listeners are removed during execution
+    [...listeners].forEach(listener => listener.apply(this, args));
+    return true;
+  }
+
+  public removeAllListeners(event?: string | symbol): this {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+}

package/src/Modules/Interfaces.ts

@@ -0,0 +1,204 @@
+import { Kazagumo } from '../Kazagumo';
+import { KazagumoPlayer, KazagumoQueue } from '../Index';
+import { KazagumoTrack } from '../Managers/Supports/KazagumoTrack';
+import { Constructor } from './Utils';
+import { Track } from 'shoukaku';
+
+export interface KazagumoOptions {
+  /** Default search engine if no engine was provided. Default to youtube. If defaultSource is provided, this will be ignored */
+  defaultSearchEngine: SearchEngines;
+  /** Default source if no source was provided. Default to defaultSearchEngine */
+  defaultSource?: string;
+  /** Kazagumo plugins */
+  plugins?: KazagumoPlugin[];
+  /** Source that will be forced to resolve when playing it */
+  sourceForceResolve?: string[];
+  /** The track resolver. Make sure you set <KazagumoTrack>.track for it to work. (I'm not responsible for any error during playback if you don't set it right) */
+  trackResolver?: (this: KazagumoTrack, options?: ResolveOptions) => Promise<boolean>;
+  /** The default youtube thumbnail's size */
+  defaultYoutubeThumbnail?: YoutubeThumbnail;
+  /** Extend some of the Structures */
+  extends?: {
+    player?: Constructor<KazagumoPlayer>;
+  };
+  /** Send to guild's shard */
+  send: (guildId: string, payload: Payload) => void;
+}
+
+export type SearchEngines = 'youtube' | 'soundcloud' | 'youtube_music' | string;
+export type YoutubeThumbnail = 'default' | 'hqdefault' | 'mqdefault' | 'sddefault' | 'maxresdefault';
+
+export interface Payload {
+  /** The OP code */
+  op: number;
+  d: {
+    guild_id: string;
+    channel_id: string | null;
+    self_mute: boolean;
+    self_deaf: boolean;
+  };
+}
+
+export const escapeRegExp = (str: string) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+export const SourceIDs = {
+  youtube: 'yt',
+  youtube_music: 'ytm',
+  soundcloud: 'sc',
+};
+
+export interface KazagumoPlayerOptions {
+  guildId: string;
+  voiceId: string;
+  textId?: string;
+  deaf: boolean;
+  volume: number;
+  /** Whether the node for searching track should be the same as the node for playing track. Default: true */
+  searchWithSameNode?: boolean;
+  extends?: {
+    queue?: Constructor<KazagumoQueue>;
+  };
+}
+
+export interface ResolveOptions {
+  overwrite?: boolean;
+  forceResolve?: boolean;
+  player?: KazagumoPlayer;
+}
+
+export interface CreatePlayerOptions {
+  /** The player's guild ID */
+  guildId: string;
+  /** The player's voice ID */
+  voiceId: string;
+  /** The player's text ID */
+  textId?: string;
+  /** Whether the bot should deafen */
+  deaf?: boolean;
+  /** Whether the bot should mute */
+  mute?: boolean;
+  /** The player's guild's shardId */
+  shardId?: number;
+  /** Balance the node? */
+  loadBalancer?: boolean;
+  /** The player's volume */
+  volume?: number;
+  /** Use specific node */
+  nodeName?: string;
+  /** The player's data, usable when you extends it */
+  data?: unknown;
+}
+
+export interface RawTrack {
+  track: string;
+  info: {
+    title: string;
+    uri?: string;
+    identifier: string;
+    sourceName: string;
+    isSeekable: boolean;
+    isStream: boolean;
+    author?: string;
+    length?: number;
+    position?: number;
+    artworkUrl?: string;
+  };
+  _raw: Track;
+}
+
+export const Events = {
+  // Player events
+  PlayerDestroy: 'playerDestroy',
+  PlayerCreate: 'playerCreate',
+  PlayerStart: 'playerStart',
+  PlayerEnd: 'playerEnd',
+  PlayerEmpty: 'playerEmpty',
+  PlayerClosed: 'playerClosed',
+  PlayerUpdate: 'playerUpdate',
+  PlayerException: 'playerException',
+  PlayerError: 'playerError',
+  PlayerResumed: 'playerResumed',
+  PlayerStuck: 'playerStuck',
+  PlayerResolveError: 'playerResolveError',
+  PlayerMoved: 'playerMoved',
+  QueueUpdate: 'queueUpdate',
+
+  // Kazagumo events
+  Debug: 'debug',
+};
+
+export interface PlayerMovedChannels {
+  oldChannelId?: string | null;
+  newChannelId?: string | null;
+}
+
+export type PlayerMovedState = 'UNKNOWN' | 'JOINED' | 'LEFT' | 'MOVED';
+
+export interface KazagumoSearchOptions {
+  requester: unknown;
+  source?: string;
+  engine?: SearchEngines;
+  nodeName?: string;
+}
+
+export interface KazagumoSearchResult {
+  type: SearchResultTypes;
+  playlistName?: string;
+  tracks: KazagumoTrack[];
+}
+
+export type SearchResultTypes = 'PLAYLIST' | 'TRACK' | 'SEARCH';
+
+export const SupportedSources = [
+  'bandcamp',
+  'beam',
+  'getyarn',
+  'http',
+  'local',
+  'nico',
+  'soundcloud',
+  'stream',
+  'twitch',
+  'vimeo',
+  'youtube',
+  'spotify',
+];
+
+export interface PlayOptions {
+  position?: number;
+  endTime?: number;
+  volume?: number;
+  paused?: boolean;
+  replaceCurrent?: boolean;
+}
+
+export enum PlayerState {
+  CONNECTING,
+  CONNECTED,
+  DISCONNECTING,
+  DISCONNECTED,
+  DESTROYING,
+  DESTROYED,
+}
+
+export class KazagumoPlugin {
+  public load(kazagumo: Kazagumo): void {
+    throw new KazagumoError(1, 'Plugin must implement load()');
+  }
+
+  public unload(kazagumo: Kazagumo): void {
+    throw new KazagumoError(1, 'Plugin must implement unload()');
+  }
+}
+
+
+export class KazagumoError extends Error {
+  public code: number;
+  public message: string;
+
+  public constructor(code: number, message: string) {
+    super(message);
+    this.code = code;
+    this.message = message;
+  }
+}

package/src/Modules/Plugins.ts

@@ -0,0 +1,5 @@
+import { KazagumoPlugin as PlayerMoved } from '../Plugins/PlayerMoved';
+
+export default {
+  PlayerMoved,
+};

package/src/Modules/Utils.ts

@@ -0,0 +1,26 @@
+import { Track } from 'shoukaku';
+import { KazagumoTrack } from '../Managers/Supports/KazagumoTrack';
+
+export class KazagumoUtils {
+  static convertKazagumoTrackToTrack(track: KazagumoTrack | Track): Track {
+    if ((track as Track).info) return track as Track;
+    track = track as KazagumoTrack;
+    return {
+      encoded: track.track,
+      info: {
+        isSeekable: track.isSeekable,
+        isStream: track.isStream,
+        title: track.title,
+        uri: track.uri,
+        identifier: track.identifier,
+        sourceName: track.sourceName,
+        author: track.author ?? '',
+        length: track.length ?? 0,
+        position: track.position ?? 0,
+      },
+      pluginInfo: {},
+    };
+  }
+}
+// Credit: Deivu (developer of Shoukaku) https://github.com/shipgirlproject/Shoukaku/blob/e7d94081cabbda7327dc04e467a45fcda49c24f2/src/Utils.ts#L1C1-L2C1
+export type Constructor<T> = new (...args: any[]) => T;

package/src/Plugins/PlayerMoved.ts

@@ -0,0 +1,54 @@
+import { Kazagumo, Events } from '../Index';
+import { KazagumoPlugin as Plugin } from '../Modules/Interfaces';
+
+export class KazagumoPlugin extends Plugin {
+  /**
+   * Kazagumo instance.
+   */
+  public kazagumo: Kazagumo | null = null;
+
+  /**
+   * Initialize the plugin.
+   * @param client Discord.Client
+   */
+  constructor(public client: any) {
+    super();
+  }
+
+  /**
+   * Load the plugin.
+   * @param kazagumo Kazagumo
+   */
+  public load(kazagumo: Kazagumo): void {
+    this.kazagumo = kazagumo;
+    this.client.on('voiceStateUpdate', this.onVoiceStateUpdate.bind(this));
+  }
+
+  /**
+   * Unload the plugin.
+   */
+  public unload(): void {
+    this.client.removeListener('voiceStateUpdate', this.onVoiceStateUpdate.bind(this));
+    this.kazagumo = null;
+  }
+
+  private onVoiceStateUpdate(oldState: any, newState: any): void {
+    if (!this.kazagumo || oldState.id !== this.client.user.id) return;
+
+    const newChannelId = newState.channelID || newState.channelId;
+    const oldChannelId = oldState.channelID || oldState.channelId;
+    const guildId = newState.guild.id;
+
+    const player = this.kazagumo.players.get(guildId);
+    if (!player) return;
+
+    let state = 'UNKNOWN';
+    if (!oldChannelId && newChannelId) state = 'JOINED';
+    else if (oldChannelId && !newChannelId) state = 'LEFT';
+    else if (oldChannelId && newChannelId && oldChannelId !== newChannelId) state = 'MOVED';
+
+    if (state === 'UNKNOWN') return;
+
+    this.kazagumo.emit(Events.PlayerMoved, player, state, { oldChannelId, newChannelId });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "types": ["bun-types"]
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/__tests__/*",
+    "test",
+    "dist"
+  ]
+}

package/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": ["tslint:recommended", "tslint-config-prettier"]
+ }