@mwyeow/moonify.js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mwyeow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# Moonify.JS
+
+<p align="center">
+  <a href="https://discord.gg/Bjgx9gaaHG">
+    <img src="https://img.shields.io/discord/1338630753512325242?color=5865F2&logo=discord&logoColor=white" alt="Discord" />
+  </a>
+  <a href="https://www.npmjs.com/package/moonify.js">
+    <img src="https://img.shields.io/npm/v/moonify.js?color=CB3837&logo=npm" alt="npm version" />
+  </a>
+  <a href="https://www.npmjs.com/package/moonify.js">
+    <img src="https://img.shields.io/npm/dt/moonify.js?color=blue" alt="npm downloads" />
+  </a>
+  <a href="https://github.com/mwyeow/moonify.js/graphs/contributors">
+    <img src="https://img.shields.io/github/contributors/mwyeow/moonify.js?color=teal" alt="Contributors" />
+  </a>
+  <a href="https://github.com/mwyeow/moonify.js/commits/main">
+    <img src="https://img.shields.io/github/last-commit/mwyeow/moonify.js" alt="Last Commit" />
+  </a>
+  <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License" />
+</p>
+
+A lightweight TypeScript client to fetch currently playing scrobbles from Last.fm and automatically enrich them with Spotify track links, artist URLs, and repeat tracking.
+
+---
+
+## Features
+
+- Fetches live playback status via Last.fm API.
+- Automatically searches Spotify for track and artist links.
+- Gracefully falls back to Last.fm URLs if Spotify credentials are unset or the track is not found.
+- Detects whether the current track is on repeat across the user's latest scrobbles.
+- Zero external runtime dependencies (uses native web APIs: `fetch`, `AbortController`, `btoa`).
+- Works across Node.js (18+), Bun, and Deno.
+
+---
+
+## Installation
+
+```bash
+# using bun
+bun add moonify.js
+
+# using npm
+npm install moonify.js
+
+# using pnpm
+pnpm add moonify.js
+
+```
+
+---
+
+## Quick Start
+
+```typescript
+import { Moonify } from "moonify.js";
+
+const moonify = new Moonify({
+  lastfmApiKey: process.env.LASTFM_API_KEY!,
+  spotifyClientId: process.env.SPOTIFY_CLIENT_ID, // optional
+  spotifyClientSecret: process.env.SPOTIFY_CLIENT_SECRET, // optional
+  requestTimeoutMs: 8000, // optional (default: 8000)
+});
+
+async function run() {
+  const result = await moonify.getCurrentlyPlaying("some_username");
+
+  if (!result) {
+    console.log("No track is playing right now.");
+    return;
+  }
+
+  console.log(`${result.trackName} by ${result.artistName}`);
+  console.log(`Listen here: ${result.trackUrl}`);
+
+  if (result.isOnRepeat) {
+    console.log(`Repeated ${result.repeatCount} times recently.`);
+  }
+}
+
+run();
+```
+
+---
+
+## Response Object
+
+`getCurrentlyPlaying(username)` resolves to `null` if nothing is playing or user scrobbles are empty. When active, it returns:
+
+| Field              | Type      | Description                                              |
+| ------------------ | --------- | -------------------------------------------------------- |
+| `trackName`        | `string`  | Track name                                               |
+| `artistName`       | `string`  | Artist name                                              |
+| `trackUrl`         | `string`  | Spotify track URL (falls back to Last.fm URL)            |
+| `artistUrl`        | `string`  | Spotify artist URL (falls back to Last.fm URL)           |
+| `lastFmTrackUrl`   | `string`  | Guaranteed Last.fm track URL                             |
+| `lastFmArtistUrl`  | `string`  | Guaranteed Last.fm artist URL                            |
+| `spotifyTrackUrl`  | `string`  | Direct Spotify track URL (null if unfound/unconfigured)  |
+| `spotifyArtistUrl` | `string`  | Direct Spotify artist URL (null if unfound/unconfigured) |
+| `isOnRepeat`       | `boolean` | `true` if repeated 2+ times in recent 10 tracks          |
+| `repeatCount`      | `number`  | Total repeat count in recent tracks                      |
+
+## Contributing
+
+Contributions are always welcome!
+If you've found a bug, have an idea, or want to improve MoonifyJS, feel free to open an issue or pull request.
+Thanks for helping out! <3

package/dist/index.cjs

@@ -0,0 +1,239 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LastFmService: () => LastFmService,
+  Moonify: () => Moonify,
+  MoonifyApiError: () => MoonifyApiError,
+  MoonifyAuthError: () => MoonifyAuthError,
+  MoonifyError: () => MoonifyError,
+  SpotifyService: () => SpotifyService
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/index.ts
+var MoonifyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MoonifyError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var MoonifyApiError = class extends MoonifyError {
+  status;
+  service;
+  constructor(service, status, message) {
+    super(`${service} api error (${status}): ${message}`);
+    this.name = "MoonifyApiError";
+    this.service = service;
+    this.status = status;
+  }
+};
+var MoonifyAuthError = class extends MoonifyError {
+  constructor(service, message) {
+    super(`could not authenticate with ${service}: ${message}`);
+    this.name = "MoonifyAuthError";
+  }
+};
+
+// src/http/fetcher.ts
+async function requestJson(service, url, options = {}) {
+  const { headers, body, method = "GET", timeoutMs = 8e3 } = options;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      body,
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "Unknown response body");
+      throw new MoonifyApiError(service, res.status, errorText);
+    }
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/services/lastfm.service.ts
+var LastFmService = class {
+  apiKey;
+  timeoutMs;
+  constructor(apiKey, timeoutMs = 8e3) {
+    this.apiKey = apiKey;
+    this.timeoutMs = timeoutMs;
+  }
+  async getRecentTracks(username, limit = 10) {
+    const url = `https://ws.audioscrobbler.com/2.0/?method=user.getrecenttracks&user=${encodeURIComponent(
+      username
+    )}&api_key=${this.apiKey}&format=json&limit=${limit}`;
+    const data = await requestJson("lastfm", url, {
+      timeoutMs: this.timeoutMs
+    });
+    const raw = data.recenttracks?.track;
+    if (!raw) return [];
+    return Array.isArray(raw) ? raw : [raw];
+  }
+};
+
+// src/services/spotify.service.ts
+var SpotifyService = class {
+  clientId;
+  clientSecret;
+  timeoutMs;
+  token = null;
+  tokenExpiresAt = 0;
+  constructor(clientId, clientSecret, timeoutMs = 8e3) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.timeoutMs = timeoutMs;
+  }
+  get isConfigured() {
+    return Boolean(this.clientId && this.clientSecret);
+  }
+  async getAccessToken() {
+    if (!this.isConfigured) return null;
+    if (this.token && Date.now() < this.tokenExpiresAt) {
+      return this.token;
+    }
+    try {
+      const credentials = btoa(`${this.clientId}:${this.clientSecret}`);
+      const data = await requestJson(
+        "spotify",
+        "https://accounts.spotify.com/api/token",
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Basic ${credentials}`,
+            "Content-Type": "application/x-www-form-urlencoded"
+          },
+          body: "grant_type=client_credentials",
+          timeoutMs: this.timeoutMs
+        }
+      );
+      this.token = data.access_token;
+      this.tokenExpiresAt = Date.now() + (data.expires_in - 60) * 1e3;
+      return this.token;
+    } catch (error) {
+      throw new MoonifyAuthError("spotify", error.message);
+    }
+  }
+  async resolveTrack(track, artist) {
+    if (!this.isConfigured) {
+      return { trackUrl: null, artistUrl: null };
+    }
+    try {
+      const token = await this.getAccessToken();
+      if (!token) return { trackUrl: null, artistUrl: null };
+      const query = encodeURIComponent(`track:${track} artist:${artist}`);
+      const data = await requestJson(
+        "spotify",
+        `https://api.spotify.com/v1/search?q=${query}&type=track&limit=1`,
+        {
+          headers: { Authorization: `Bearer ${token}` },
+          timeoutMs: this.timeoutMs
+        }
+      );
+      const item = data.tracks?.items?.[0];
+      if (!item) return { trackUrl: null, artistUrl: null };
+      return {
+        trackUrl: item.external_urls?.spotify || null,
+        artistUrl: item.artists?.[0]?.external_urls?.spotify || null
+      };
+    } catch {
+      return { trackUrl: null, artistUrl: null };
+    }
+  }
+};
+
+// src/utils/normalise.ts
+function normalizeString(input) {
+  return input.trim().toLowerCase();
+}
+
+// src/client.ts
+var Moonify = class {
+  lastfm;
+  spotify;
+  constructor(config) {
+    if (!config.lastfmApiKey) {
+      throw new Error("lastfm api key is required.");
+    }
+    this.lastfm = new LastFmService(
+      config.lastfmApiKey,
+      config.requestTimeoutMs
+    );
+    this.spotify = new SpotifyService(
+      config.spotifyClientId,
+      config.spotifyClientSecret,
+      config.requestTimeoutMs
+    );
+  }
+  async getCurrentlyPlaying(username) {
+    const tracks = await this.lastfm.getRecentTracks(username, 10);
+    if (tracks.length === 0) return null;
+    const currentTrack = tracks[0];
+    const isNowPlaying = currentTrack["@attr"]?.nowplaying === "true";
+    if (!isNowPlaying) return null;
+    const trackName = currentTrack.name;
+    const artistName = currentTrack.artist["#text"] || currentTrack.artist.name || "Unknown Artist";
+    const lastFmTrackUrl = currentTrack.url;
+    const lastFmArtistUrl = `https://www.last.fm/music/${encodeURIComponent(artistName)}`;
+    const spotifyMatch = await this.spotify.resolveTrack(trackName, artistName);
+    const normTrack = normalizeString(trackName);
+    const normArtist = normalizeString(artistName);
+    let repeatCount = 0;
+    for (let i = 1; i < tracks.length; i++) {
+      const item = tracks[i];
+      const tName = normalizeString(item.name || "");
+      const tArtist = normalizeString(
+        item.artist["#text"] || item.artist.name || ""
+      );
+      if (tName === normTrack && tArtist === normArtist) {
+        repeatCount++;
+      }
+    }
+    return {
+      trackName,
+      artistName,
+      trackUrl: spotifyMatch.trackUrl || lastFmTrackUrl,
+      artistUrl: spotifyMatch.artistUrl || lastFmArtistUrl,
+      lastFmTrackUrl,
+      lastFmArtistUrl,
+      spotifyTrackUrl: spotifyMatch.trackUrl,
+      spotifyArtistUrl: spotifyMatch.artistUrl,
+      isOnRepeat: repeatCount >= 2,
+      repeatCount
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LastFmService,
+  Moonify,
+  MoonifyApiError,
+  MoonifyAuthError,
+  MoonifyError,
+  SpotifyService
+});

package/dist/index.d.cts

@@ -0,0 +1,83 @@
+interface MoonifyConfig {
+    lastfmApiKey: string;
+    spotifyClientId?: string;
+    spotifyClientSecret?: string;
+    requestTimeoutMs?: number;
+}
+
+interface ResolvedCurrentlyPlaying {
+    trackName: string;
+    artistName: string;
+    trackUrl: string;
+    artistUrl: string;
+    lastFmTrackUrl: string;
+    lastFmArtistUrl: string;
+    spotifyTrackUrl: string | null;
+    spotifyArtistUrl: string | null;
+    isOnRepeat: boolean;
+    repeatCount: number;
+}
+
+declare class Moonify {
+    private lastfm;
+    private spotify;
+    constructor(config: MoonifyConfig);
+    getCurrentlyPlaying(username: string): Promise<ResolvedCurrentlyPlaying | null>;
+}
+
+interface LastFmTrackArtist {
+    "#text"?: string;
+    name?: string;
+    mbid?: string;
+}
+interface LastFmRawTrack {
+    name: string;
+    artist: LastFmTrackArtist;
+    url: string;
+    streamable?: string;
+    mbid?: string;
+    album?: {
+        "#text"?: string;
+    };
+    "@attr"?: {
+        nowplaying?: string;
+    };
+}
+
+declare class LastFmService {
+    private apiKey;
+    private timeoutMs;
+    constructor(apiKey: string, timeoutMs?: number);
+    getRecentTracks(username: string, limit?: number): Promise<LastFmRawTrack[]>;
+}
+
+interface SpotifyTrackMatch {
+    trackUrl: string | null;
+    artistUrl: string | null;
+}
+
+declare class SpotifyService {
+    private clientId?;
+    private clientSecret?;
+    private timeoutMs;
+    private token;
+    private tokenExpiresAt;
+    constructor(clientId?: string, clientSecret?: string, timeoutMs?: number);
+    get isConfigured(): boolean;
+    private getAccessToken;
+    resolveTrack(track: string, artist: string): Promise<SpotifyTrackMatch>;
+}
+
+declare class MoonifyError extends Error {
+    constructor(message: string);
+}
+declare class MoonifyApiError extends MoonifyError {
+    status: number;
+    service: "lastfm" | "spotify";
+    constructor(service: "lastfm" | "spotify", status: number, message: string);
+}
+declare class MoonifyAuthError extends MoonifyError {
+    constructor(service: "lastfm" | "spotify", message: string);
+}
+
+export { type LastFmRawTrack, LastFmService, Moonify, MoonifyApiError, MoonifyAuthError, type MoonifyConfig, MoonifyError, type ResolvedCurrentlyPlaying, SpotifyService, type SpotifyTrackMatch };

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+interface MoonifyConfig {
+    lastfmApiKey: string;
+    spotifyClientId?: string;
+    spotifyClientSecret?: string;
+    requestTimeoutMs?: number;
+}
+
+interface ResolvedCurrentlyPlaying {
+    trackName: string;
+    artistName: string;
+    trackUrl: string;
+    artistUrl: string;
+    lastFmTrackUrl: string;
+    lastFmArtistUrl: string;
+    spotifyTrackUrl: string | null;
+    spotifyArtistUrl: string | null;
+    isOnRepeat: boolean;
+    repeatCount: number;
+}
+
+declare class Moonify {
+    private lastfm;
+    private spotify;
+    constructor(config: MoonifyConfig);
+    getCurrentlyPlaying(username: string): Promise<ResolvedCurrentlyPlaying | null>;
+}
+
+interface LastFmTrackArtist {
+    "#text"?: string;
+    name?: string;
+    mbid?: string;
+}
+interface LastFmRawTrack {
+    name: string;
+    artist: LastFmTrackArtist;
+    url: string;
+    streamable?: string;
+    mbid?: string;
+    album?: {
+        "#text"?: string;
+    };
+    "@attr"?: {
+        nowplaying?: string;
+    };
+}
+
+declare class LastFmService {
+    private apiKey;
+    private timeoutMs;
+    constructor(apiKey: string, timeoutMs?: number);
+    getRecentTracks(username: string, limit?: number): Promise<LastFmRawTrack[]>;
+}
+
+interface SpotifyTrackMatch {
+    trackUrl: string | null;
+    artistUrl: string | null;
+}
+
+declare class SpotifyService {
+    private clientId?;
+    private clientSecret?;
+    private timeoutMs;
+    private token;
+    private tokenExpiresAt;
+    constructor(clientId?: string, clientSecret?: string, timeoutMs?: number);
+    get isConfigured(): boolean;
+    private getAccessToken;
+    resolveTrack(track: string, artist: string): Promise<SpotifyTrackMatch>;
+}
+
+declare class MoonifyError extends Error {
+    constructor(message: string);
+}
+declare class MoonifyApiError extends MoonifyError {
+    status: number;
+    service: "lastfm" | "spotify";
+    constructor(service: "lastfm" | "spotify", status: number, message: string);
+}
+declare class MoonifyAuthError extends MoonifyError {
+    constructor(service: "lastfm" | "spotify", message: string);
+}
+
+export { type LastFmRawTrack, LastFmService, Moonify, MoonifyApiError, MoonifyAuthError, type MoonifyConfig, MoonifyError, type ResolvedCurrentlyPlaying, SpotifyService, type SpotifyTrackMatch };

package/dist/index.js

@@ -0,0 +1,207 @@
+// src/errors/index.ts
+var MoonifyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MoonifyError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var MoonifyApiError = class extends MoonifyError {
+  status;
+  service;
+  constructor(service, status, message) {
+    super(`${service} api error (${status}): ${message}`);
+    this.name = "MoonifyApiError";
+    this.service = service;
+    this.status = status;
+  }
+};
+var MoonifyAuthError = class extends MoonifyError {
+  constructor(service, message) {
+    super(`could not authenticate with ${service}: ${message}`);
+    this.name = "MoonifyAuthError";
+  }
+};
+
+// src/http/fetcher.ts
+async function requestJson(service, url, options = {}) {
+  const { headers, body, method = "GET", timeoutMs = 8e3 } = options;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      body,
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "Unknown response body");
+      throw new MoonifyApiError(service, res.status, errorText);
+    }
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/services/lastfm.service.ts
+var LastFmService = class {
+  apiKey;
+  timeoutMs;
+  constructor(apiKey, timeoutMs = 8e3) {
+    this.apiKey = apiKey;
+    this.timeoutMs = timeoutMs;
+  }
+  async getRecentTracks(username, limit = 10) {
+    const url = `https://ws.audioscrobbler.com/2.0/?method=user.getrecenttracks&user=${encodeURIComponent(
+      username
+    )}&api_key=${this.apiKey}&format=json&limit=${limit}`;
+    const data = await requestJson("lastfm", url, {
+      timeoutMs: this.timeoutMs
+    });
+    const raw = data.recenttracks?.track;
+    if (!raw) return [];
+    return Array.isArray(raw) ? raw : [raw];
+  }
+};
+
+// src/services/spotify.service.ts
+var SpotifyService = class {
+  clientId;
+  clientSecret;
+  timeoutMs;
+  token = null;
+  tokenExpiresAt = 0;
+  constructor(clientId, clientSecret, timeoutMs = 8e3) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.timeoutMs = timeoutMs;
+  }
+  get isConfigured() {
+    return Boolean(this.clientId && this.clientSecret);
+  }
+  async getAccessToken() {
+    if (!this.isConfigured) return null;
+    if (this.token && Date.now() < this.tokenExpiresAt) {
+      return this.token;
+    }
+    try {
+      const credentials = btoa(`${this.clientId}:${this.clientSecret}`);
+      const data = await requestJson(
+        "spotify",
+        "https://accounts.spotify.com/api/token",
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Basic ${credentials}`,
+            "Content-Type": "application/x-www-form-urlencoded"
+          },
+          body: "grant_type=client_credentials",
+          timeoutMs: this.timeoutMs
+        }
+      );
+      this.token = data.access_token;
+      this.tokenExpiresAt = Date.now() + (data.expires_in - 60) * 1e3;
+      return this.token;
+    } catch (error) {
+      throw new MoonifyAuthError("spotify", error.message);
+    }
+  }
+  async resolveTrack(track, artist) {
+    if (!this.isConfigured) {
+      return { trackUrl: null, artistUrl: null };
+    }
+    try {
+      const token = await this.getAccessToken();
+      if (!token) return { trackUrl: null, artistUrl: null };
+      const query = encodeURIComponent(`track:${track} artist:${artist}`);
+      const data = await requestJson(
+        "spotify",
+        `https://api.spotify.com/v1/search?q=${query}&type=track&limit=1`,
+        {
+          headers: { Authorization: `Bearer ${token}` },
+          timeoutMs: this.timeoutMs
+        }
+      );
+      const item = data.tracks?.items?.[0];
+      if (!item) return { trackUrl: null, artistUrl: null };
+      return {
+        trackUrl: item.external_urls?.spotify || null,
+        artistUrl: item.artists?.[0]?.external_urls?.spotify || null
+      };
+    } catch {
+      return { trackUrl: null, artistUrl: null };
+    }
+  }
+};
+
+// src/utils/normalise.ts
+function normalizeString(input) {
+  return input.trim().toLowerCase();
+}
+
+// src/client.ts
+var Moonify = class {
+  lastfm;
+  spotify;
+  constructor(config) {
+    if (!config.lastfmApiKey) {
+      throw new Error("lastfm api key is required.");
+    }
+    this.lastfm = new LastFmService(
+      config.lastfmApiKey,
+      config.requestTimeoutMs
+    );
+    this.spotify = new SpotifyService(
+      config.spotifyClientId,
+      config.spotifyClientSecret,
+      config.requestTimeoutMs
+    );
+  }
+  async getCurrentlyPlaying(username) {
+    const tracks = await this.lastfm.getRecentTracks(username, 10);
+    if (tracks.length === 0) return null;
+    const currentTrack = tracks[0];
+    const isNowPlaying = currentTrack["@attr"]?.nowplaying === "true";
+    if (!isNowPlaying) return null;
+    const trackName = currentTrack.name;
+    const artistName = currentTrack.artist["#text"] || currentTrack.artist.name || "Unknown Artist";
+    const lastFmTrackUrl = currentTrack.url;
+    const lastFmArtistUrl = `https://www.last.fm/music/${encodeURIComponent(artistName)}`;
+    const spotifyMatch = await this.spotify.resolveTrack(trackName, artistName);
+    const normTrack = normalizeString(trackName);
+    const normArtist = normalizeString(artistName);
+    let repeatCount = 0;
+    for (let i = 1; i < tracks.length; i++) {
+      const item = tracks[i];
+      const tName = normalizeString(item.name || "");
+      const tArtist = normalizeString(
+        item.artist["#text"] || item.artist.name || ""
+      );
+      if (tName === normTrack && tArtist === normArtist) {
+        repeatCount++;
+      }
+    }
+    return {
+      trackName,
+      artistName,
+      trackUrl: spotifyMatch.trackUrl || lastFmTrackUrl,
+      artistUrl: spotifyMatch.artistUrl || lastFmArtistUrl,
+      lastFmTrackUrl,
+      lastFmArtistUrl,
+      spotifyTrackUrl: spotifyMatch.trackUrl,
+      spotifyArtistUrl: spotifyMatch.artistUrl,
+      isOnRepeat: repeatCount >= 2,
+      repeatCount
+    };
+  }
+};
+export {
+  LastFmService,
+  Moonify,
+  MoonifyApiError,
+  MoonifyAuthError,
+  MoonifyError,
+  SpotifyService
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@mwyeow/moonify.js",
+  "version": "1.0.0",
+  "description": "Resolve Last.fm currently playing track and enrich with Spotify metadata",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mwyeow/moonify.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mwyeow/moonify.js/issues"
+  },
+  "homepage": "https://github.com/mwyeow/moonify.js#readme",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "test": "bun test",
+    "test:live": "bun run test/live.ts",
+    "prepublishOnly": "bun run build"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0"
+  }
+}