@aceandgaming/swarmfm-api 1.0.0

package/README.md

@@ -0,0 +1,63 @@
+# SwarmFMApi
+`SwarmFMApi` is a lightweight JavaScript/TypeScript API for integrating and controlling [SwarmFM](https://player.sw.arm.fm/)
+music playback in your web applications. It allows you to embed the SwarmFM player via an iframe, control playback programmatically, and respond to metadata and playback events.
+
+**Note: This api is unofficial and not affiliated with SwarmFM or boop.**
+
+This api uses server-side injection and thus the normal SwarmFM domains won't work. If creating the iframe manually you must use `swarmfm.swarmtunes.com`.
+
+## Usage
+```TS
+import SwarmFMApi from 'swarmfm-api';
+
+// Create an instance
+const api = new SwarmFMApi();
+
+// Create and attach iframe
+const iframe = api.CreateIFrame({ silent: 'injector', autoplay: false, controls: true });
+document.body.appendChild(iframe);
+
+api.WaitForReady().then(() => {
+    // Play or pause
+    api.Play();
+    api.Pause();
+})
+
+
+// Listen to events
+api.addEventListener('onplay', () => console.log('Music started playing'));
+api.addEventListener('onmetadatachange', (metadata) => console.log('Now playing:', metadata.current));
+```
+
+## API
+
+### Properties
+
+|Property|Type|Description|
+|--------|----|-----------|
+|`Playing`      |`boolean`|                     Get or set whether the player is currently playing. Setting `true` plays, false `pauses`.|
+|`Paused`       |`boolean`|                     Get or set whether the player is paused. Inverse of `Playing`.|
+|`Current`      |`TrackMetadata?`|   Returns metadata of the currently playing track.|
+|`Previous`     |`TrackMetadata?`|   Returns metadata of the previous track.|
+|`Next`         |`TrackMetadata?`|   Returns metadata of the next track.|
+
+### Methods
+
+|Method|Description|
+|------|-----------|
+|`CreateIFrame(options?)`|                      Creates a iframe and automaticly attaches it|
+|`Attach(iframe: HTMLIFrameElement)`|           Attaches the API to an existing SwarmFM iframe and listens for events.
+|`Play()`|                                      Sends a message to the iframe to start playback.|
+|`Pause()`|                                     Sends a message to the iframe to pause playback.|
+|`WaitForReady()`|                              A async function that resolves when the player is ready|
+|`addEventListener(event: string, callback: Function)`|Registers an event listener.
+|`removeEventListener(event: string, callback: Function)`|Removes a previously registered listener.|
+
+### Events
+
+| Event              | Arguments                   | Description                                                      |
+| ------------------ | --------------------------- | ---------------------------------------------------------------- |
+| `onplay`           | None                        | Triggered when playback starts.                                  |
+| `onpause`          | None                        | Triggered when playback is paused.                               |
+| `onmetadatachange` | `metadata: SwarmFMMetadata` | Triggered when track metadata updates (current, previous, next). |
+| `onready`          | None                        | Triggered when the player is ready for playback.                 |

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+export type SwarmFMSong = {
+    artist: string;
+    bpm: number;
+    duration: number;
+    id: string;
+    name: string;
+    singer: string[];
+    album_cover_id?: string;
+};
+export type SwarmFMMetadata = {
+    previous: SwarmFMSong;
+    current: SwarmFMSong;
+    next: SwarmFMSong;
+    position: number;
+};
+interface SwarmFMEventMap {
+    "onplay": () => void;
+    "onpause": () => void;
+    "onmetadatachange": (metadata: SwarmFMMetadata) => void;
+    "onready": () => void;
+}
+export default class SwarmFMApi {
+    get Playing(): boolean;
+    get Paused(): boolean;
+    set Playing(playing: boolean);
+    set Paused(paused: boolean);
+    get Current(): SwarmFMSong | undefined;
+    get Previous(): SwarmFMSong | undefined;
+    get Next(): SwarmFMSong | undefined;
+    private metadata?;
+    private iframe?;
+    private playing;
+    private callbacks;
+    Attach(iframe: HTMLIFrameElement): void;
+    CreateIFrame(ops?: {
+        silent: "site" | "injector" | "all";
+        "autoplay": boolean;
+        "controls": boolean;
+    }): HTMLIFrameElement;
+    Play(): void;
+    Pause(): void;
+    WaitForReady(): Promise<void>;
+    addEventListener(event: keyof SwarmFMEventMap, callback: SwarmFMEventMap[keyof SwarmFMEventMap]): void;
+    removeEventListener(event: keyof SwarmFMEventMap, callback: SwarmFMEventMap[keyof SwarmFMEventMap]): void;
+    private dispatchEvent;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,115 @@
+export default class SwarmFMApi {
+    constructor() {
+        this.playing = false;
+        this.callbacks = {};
+    }
+    get Playing() {
+        return this.playing;
+    }
+    get Paused() {
+        return !this.playing;
+    }
+    set Playing(playing) {
+        if (playing) {
+            this.Play();
+        }
+        else {
+            this.Pause();
+        }
+    }
+    set Paused(paused) {
+        this.Playing = !paused;
+    }
+    get Current() {
+        var _a;
+        return (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.current;
+    }
+    get Previous() {
+        var _a;
+        return (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.previous;
+    }
+    get Next() {
+        var _a;
+        return (_a = this.metadata) === null || _a === void 0 ? void 0 : _a.next;
+    }
+    Attach(iframe) {
+        this.iframe = iframe;
+        window.onmessage = (event) => {
+            if (event.origin !== "https://swarmfm.swarmtunes.com") {
+                return;
+            }
+            switch (event.data.type) {
+                case "SWARMFM_METADATA":
+                    this.metadata = event.data.data;
+                    if (this.metadata) {
+                        this.dispatchEvent("onmetadatachange", this.metadata);
+                    }
+                    break;
+                case "SWARMFM_PLAYING":
+                    this.playing = true;
+                    this.dispatchEvent("onplay");
+                    break;
+                case "SWARMFM_PAUSED":
+                    this.playing = false;
+                    this.dispatchEvent("onpause");
+                    break;
+                case "SWARMFM_READY":
+                    this.dispatchEvent("onready");
+                    break;
+            }
+        };
+    }
+    CreateIFrame(ops = { silent: "injector", autoplay: false, controls: true }) {
+        const iframe = document.createElement("iframe");
+        const prams = new URLSearchParams();
+        prams.set("silent", ops.silent);
+        prams.set("autoplay", ops.autoplay.toString());
+        prams.set("nocontrols", (!ops.controls).toString());
+        iframe.src = `https://swarmfm.swarmtunes.com/${prams.toString()}`;
+        this.Attach(iframe);
+        return iframe;
+    }
+    Play() {
+        var _a, _b;
+        (_b = (_a = this.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow) === null || _b === void 0 ? void 0 : _b.postMessage({
+            type: "SWARMFM_PLAY"
+        }, "*");
+    }
+    Pause() {
+        var _a, _b;
+        (_b = (_a = this.iframe) === null || _a === void 0 ? void 0 : _a.contentWindow) === null || _b === void 0 ? void 0 : _b.postMessage({
+            type: "SWARMFM_PAUSE"
+        }, "*");
+    }
+    WaitForReady() {
+        return new Promise((resolve) => {
+            this.addEventListener("onready", () => {
+                resolve();
+            });
+        });
+    }
+    addEventListener(event, callback) {
+        if (this.callbacks[event] == null) {
+            this.callbacks[event] = [];
+        }
+        this.callbacks[event].push(callback);
+    }
+    removeEventListener(event, callback) {
+        if (this.callbacks[event] == null) {
+            return;
+        }
+        const index = this.callbacks[event].indexOf(callback);
+        if (index > -1) {
+            this.callbacks[event].splice(index, 1);
+        }
+    }
+    dispatchEvent(event, ...args) {
+        if (this.callbacks[event] == null) {
+            return;
+        }
+        for (const callback of this.callbacks[event]) {
+            // @ts-ignore
+            callback(...args);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@aceandgaming/swarmfm-api",
+  "version": "1.0.0",
+  "description": "A API for integrating and controlling SwarmFM",
+  "main": "dist/index.ts",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "swarmfm",
+    "music",
+    "iframe",
+    "api",
+    "typescript"
+  ],
+  "author": "aceandgaming",
+  "license": "MIT",
+  "type": "commonjs",
+  "devDependencies": {
+    "typescript": "^6.0.2"
+  }
+}