@ansango/lastfm-api 3.1.3

package/README.md

@@ -0,0 +1,470 @@
+# @ansango/lastfm-api
+
+[![NPM Version](https://img.shields.io/npm/v/%40ansango%2Flastfm-api.svg?branch=main)](https://www.npmjs.com/package/@ansango/lastfm-api)
+[![Downloads Per Week](https://img.shields.io/npm/dw/%40ansango%2Flastfm-api.svg?color=blue)](https://www.npmjs.com/package/@ansango/lastfm-api)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+A universal Last.fm API client for Node.js and Browser, written in TypeScript.
+
+> [!NOTE]
+> This package was previously published as `lastfm-client-ts`. The legacy package remains
+> installable but is deprecated. Migrate by installing `@ansango/lastfm-api` and updating the
+> package specifier in your imports; the exported API and subpaths are unchanged.
+
+## Features
+
+- ✅ **Universal**: Works in Node.js (≥20.0.0) and Browser
+- ✅ **TypeScript**: Full type safety with comprehensive type definitions
+- ✅ **Zod Schemas**: Runtime validation schemas for all types
+- ✅ **ESM**: Modern ES modules with tree-shaking support
+- ✅ **Flexible**: Global configuration or per-instance configuration
+- ✅ **Modular**: Import only what you need
+- ✅ **Minimal Dependencies**: Only `js-md5` for API signatures and `zod` for runtime validation
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+  - [Using the Client Class](#using-the-client-class)
+  - [Using Global Configuration](#using-global-configuration)
+  - [Using Individual Services](#using-individual-services)
+- [Environment Variables](#environment-variables)
+- [Authentication & Scrobbling](#authentication--scrobbling)
+- [Error Handling](#error-handling)
+- [API Reference](#api-reference)
+- [TypeScript Support](#typescript-support)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+
+```bash
+npm install @ansango/lastfm-api
+```
+
+**Requirements:**
+- Node.js ≥ 20.0.0 (for native fetch support)
+- Modern browsers with fetch API support
+
+## Quick Start
+
+```typescript
+import { LastFmClient } from '@ansango/lastfm-api';
+
+// Create a client instance
+const client = new LastFmClient({
+  apiKey: 'YOUR_API_KEY'
+});
+
+// Fetch user information
+const userInfo = await client.user.getInfo({ user: 'ansango' });
+console.log(userInfo);
+
+// Search for albums
+const albums = await client.album.search({ album: 'Believe' });
+console.log(albums);
+```
+
+## Usage
+
+### Using the Client Class (Recommended)
+
+The client class provides access to all API services in one place:
+
+```typescript
+import { LastFmClient } from '@ansango/lastfm-api';
+
+const client = new LastFmClient({
+  apiKey: 'YOUR_API_KEY',
+  sharedSecret: 'YOUR_SHARED_SECRET', // Optional, required for authenticated methods
+  sessionKey: 'USER_SESSION_KEY'      // Optional, required for user-specific methods
+});
+
+// User service
+const userInfo = await client.user.getInfo({ user: 'ansango' });
+const topArtists = await client.user.getTopArtists({ user: 'ansango', period: '7day' });
+
+// Album service
+const albumInfo = await client.album.getInfo({ artist: 'Cher', album: 'Believe' });
+const albumSearch = await client.album.search({ album: 'Believe', limit: 10 });
+
+// Artist service
+const artistInfo = await client.artist.getInfo({ artist: 'Radiohead' });
+const similarArtists = await client.artist.getSimilar({ artist: 'Radiohead' });
+
+// Track service
+const trackInfo = await client.track.getInfo({ artist: 'The Beatles', track: 'Yesterday' });
+const trackSearch = await client.track.search({ track: 'Yesterday', limit: 10 });
+
+// Scrobble (auth required — `sk` is auto-injected from `config.sessionKey`)
+const scrobbleResult = await client.track.scrobble({
+  artist: 'Cher',
+  track: 'Believe',
+  timestamp: Math.floor(Date.now() / 1000),
+});
+
+// Batch scrobble (max 50 tracks per call)
+const batchResult = await client.track.scrobbleMany({
+  tracks: [
+    { artist: 'Cher', track: 'Believe', timestamp: 1700000000 },
+    { artist: 'Cher', track: 'If You Believe', timestamp: 1700000600 },
+  ],
+});
+
+// Chart service
+const topChartArtists = await client.chart.getTopArtists();
+const topChartTracks = await client.chart.getTopTracks();
+
+// Tag service
+const tagInfo = await client.tag.getInfo({ tag: 'rock' });
+const topTagArtists = await client.tag.getTopArtists({ tag: 'rock' });
+
+// Geo service
+const topArtistsByCountry = await client.geo.getTopArtists({ country: 'spain' });
+
+// Library service
+const libraryArtists = await client.library.getArtists({ user: 'ansango' });
+
+// Auth service (for scrobbling and authenticated methods)
+const session = await client.auth.getSession({ token: 'AUTH_TOKEN' });
+```
+
+### Using Global Configuration
+
+Set configuration globally and reuse it across multiple client instances:
+
+```typescript
+import { setGlobalConfig, createClient } from '@ansango/lastfm-api';
+
+// Set global configuration once
+setGlobalConfig({
+  apiKey: process.env.LASTFM_API_KEY!,
+  sharedSecret: process.env.LASTFM_SHARED_SECRET
+});
+
+// Create clients without passing config
+const client1 = createClient();
+const client2 = createClient();
+
+// Both clients use the same global configuration
+const user1 = await client1.user.getInfo({ user: 'user1' });
+const user2 = await client2.user.getInfo({ user: 'user2' });
+```
+
+### Using Individual Services
+
+Import only the services you need for better tree-shaking:
+
+```typescript
+// Import only the user service
+import { createUserService } from '@ansango/lastfm-api/user';
+import type { UserGetInfoRequest } from '@ansango/lastfm-api/user';
+
+const userService = createUserService({
+  apiKey: 'YOUR_API_KEY'
+});
+
+const params: UserGetInfoRequest = { user: 'ansango' };
+const userInfo = await userService.getInfo(params);
+```
+
+```typescript
+// Import multiple services
+import { createAlbumService } from '@ansango/lastfm-api/album';
+import { createTrackService } from '@ansango/lastfm-api/track';
+
+const config = { apiKey: 'YOUR_API_KEY' };
+
+const albumService = createAlbumService(config);
+const trackService = createTrackService(config);
+
+const albums = await albumService.search({ album: 'Abbey Road' });
+const tracks = await trackService.search({ track: 'Come Together' });
+```
+
+**Available service imports:**
+- `@ansango/lastfm-api/user`
+- `@ansango/lastfm-api/album`
+- `@ansango/lastfm-api/artist`
+- `@ansango/lastfm-api/track`
+- `@ansango/lastfm-api/tag`
+- `@ansango/lastfm-api/chart`
+- `@ansango/lastfm-api/geo`
+- `@ansango/lastfm-api/library`
+- `@ansango/lastfm-api/auth`
+
+## Zod Schema Validation
+
+The library includes automatically generated Zod schemas for runtime validation. These schemas mirror all TypeScript types and can be used to validate API responses or user input at runtime.
+
+### Importing Schemas
+
+Schemas are available through modular imports, following the same pattern as the services:
+
+```typescript
+import { userGetInfoRequestSchema, userGetInfoResponseSchema } from '@ansango/lastfm-api/user/schemas';
+import { albumSearchRequestSchema } from '@ansango/lastfm-api/album/schemas';
+import { trackGetInfoResponseSchema } from '@ansango/lastfm-api/track/schemas';
+```
+
+### Usage Example
+
+```typescript
+import { userGetInfoRequestSchema, userGetInfoResponseSchema } from '@ansango/lastfm-api/user/schemas';
+
+// Validate request parameters
+const params = { user: 'ansango' };
+const validatedParams = userGetInfoRequestSchema.parse(params);
+
+// Validate API response
+const response = await fetch(`https://ws.audioscrobbler.com/2.0/...`);
+const data = await response.json();
+const validatedData = userGetInfoResponseSchema.parse(data);
+
+// Safe parsing (doesn't throw)
+const result = userGetInfoResponseSchema.safeParse(data);
+if (result.success) {
+  console.log(result.data);
+} else {
+  console.error(result.error);
+}
+```
+
+**Available schema imports:**
+- `@ansango/lastfm-api/user/schemas`
+- `@ansango/lastfm-api/album/schemas`
+- `@ansango/lastfm-api/artist/schemas`
+- `@ansango/lastfm-api/track/schemas`
+- `@ansango/lastfm-api/tag/schemas`
+- `@ansango/lastfm-api/chart/schemas`
+- `@ansango/lastfm-api/geo/schemas`
+- `@ansango/lastfm-api/library/schemas`
+- `@ansango/lastfm-api/auth/schemas`
+- `@ansango/lastfm-api/schemas` (base types like `imageSchema`, `datePropSchema`, etc.)
+
+## Environment Variables
+
+In Node.js environments, the client automatically loads configuration from environment variables:
+
+```bash
+# .env file
+LASTFM_API_KEY=your_api_key_here
+LASTFM_SHARED_SECRET=your_shared_secret_here
+LASTFM_SESSION_KEY=user_session_key_here
+
+# Optional: Custom base URL
+LASTFM_BASE_URL=https://ws.audioscrobbler.com/2.0/
+```
+
+```typescript
+// Configuration is loaded automatically from process.env
+import { createClient } from '@ansango/lastfm-api';
+
+const client = createClient(); // Uses environment variables
+```
+
+**Browser Usage:**
+
+In browser environments, pass configuration explicitly or use your bundler's environment variable system:
+
+```typescript
+// Vite
+const client = new LastFmClient({
+  apiKey: import.meta.env.VITE_LASTFM_API_KEY
+});
+
+// Webpack
+const client = new LastFmClient({
+  apiKey: process.env.REACT_APP_LASTFM_API_KEY
+});
+```
+
+## Authentication & Scrobbling
+
+Methods that mutate user state (`track.scrobble`, `track.scrobbleMany`, plus future write methods) require an authenticated session. Get one with `client.auth.getSession({ token })` after the user authorizes the token in a browser. Once you have a session key, pass it as `sessionKey` in your config — the client injects it into every authenticated call.
+
+```typescript
+import { LastFmClient } from '@ansango/lastfm-api';
+
+const client = new LastFmClient({
+  apiKey: process.env.LASTFM_API_KEY!,
+  sharedSecret: process.env.LASTFM_SHARED_SECRET!,
+  sessionKey: process.env.LASTFM_SESSION_KEY!,
+});
+
+// Scrobble a track — `sk` is auto-injected from `config.sessionKey`,
+// so you don't need to pass it explicitly.
+await client.track.scrobble({
+  artist: 'Cher',
+  track: 'Believe',
+  timestamp: Math.floor(Date.now() / 1000),
+});
+```
+
+> **Note:** The previous method names `postTrackScrobble` and `postBatchTrackScrobble` are still available as deprecated aliases. They forward to `scrobble` and `scrobbleMany` respectively and will be removed in the next major release.
+
+## Error Handling
+
+API errors throw a `LastFmApiError` that carries the HTTP status and the Last.fm error code, so consumers can distinguish failures programmatically:
+
+```typescript
+import { LastFmClient, LastFmApiError } from '@ansango/lastfm-api';
+
+try {
+  await client.user.getInfo({ user: 'nonexistent_user_xyz' });
+} catch (e) {
+  if (e instanceof LastFmApiError) {
+    console.error(`Last.fm error ${e.code}: ${e.message} (HTTP ${e.httpStatus})`);
+    // e.g. "Last.fm error 14: This token has not been authorized (HTTP 401)"
+  } else {
+    throw e;
+  }
+}
+```
+
+The `code` is the numeric error code from the [Last.fm API documentation](https://www.last.fm/api/show/user.getInfo#errors) (e.g. `9` for "Invalid session key", `10` for "Invalid API key", `29` for "Rate limit exceeded").
+
+## API Reference
+
+### Client
+
+The main client class with all services:
+
+```typescript
+class LastFmClient {
+  user: UserService;
+  album: AlbumService;
+  artist: ArtistService;
+  track: TrackService;
+  tag: TagService;
+  chart: ChartService;
+  geo: GeoService;
+  library: LibraryService;
+  auth: AuthService;
+  
+  constructor(config?: Partial<LastFmConfig>);
+  getConfig(): Readonly<LastFmConfig>;
+}
+```
+
+### Configuration
+
+```typescript
+interface LastFmConfig {
+  apiKey: string;           // Required: Your Last.fm API key
+  sharedSecret?: string;    // Optional: Required for authenticated methods
+  sessionKey?: string;      // Optional: User session key for scrobbling
+  baseUrl?: string;         // Optional: API base URL (default: https://ws.audioscrobbler.com/2.0/)
+}
+
+// Configuration functions
+function createConfig(options?: Partial<LastFmConfig>): LastFmConfig;
+function setGlobalConfig(config: Partial<LastFmConfig>): void;
+function getGlobalConfig(): LastFmConfig;
+function resetGlobalConfig(): void;
+```
+
+### Services
+
+Each service provides methods for interacting with specific Last.fm API endpoints:
+
+- **UserService**: User-related methods (getInfo, getTopArtists, getRecentTracks, etc.)
+- **AlbumService**: Album methods (getInfo, search, getTags, etc.)
+- **ArtistService**: Artist methods (getInfo, getSimilar, getTopAlbums, etc.)
+- **TrackService**: Track methods (getInfo, search, scrobble, scrobbleMany, etc.)
+- **TagService**: Tag methods (getInfo, getTopArtists, getTopTracks, etc.)
+- **ChartService**: Chart methods (getTopArtists, getTopTracks, etc.)
+- **GeoService**: Geographic methods (getTopArtists, getTopTracks by country)
+- **LibraryService**: Library methods (getArtists, etc.)
+- **AuthService**: Authentication methods (getSession, etc.)
+
+## TypeScript Support
+
+The library is fully typed with comprehensive TypeScript definitions:
+
+```typescript
+import { LastFmClient } from '@ansango/lastfm-api';
+import type {
+  UserGetInfoRequest,
+  UserGetInfoResponse,
+  AlbumSearchRequest,
+  AlbumSearchResponse
+} from '@ansango/lastfm-api';
+
+const client = new LastFmClient({ apiKey: 'YOUR_API_KEY' });
+
+// Type-safe requests and responses
+const userParams: UserGetInfoRequest = { user: 'ansango' };
+const userInfo: UserGetInfoResponse = await client.user.getInfo(userParams);
+
+const albumParams: AlbumSearchRequest = { album: 'Believe', limit: 10 };
+const albums: AlbumSearchResponse = await client.album.search(albumParams);
+```
+
+All request parameters and response types are exported for your convenience.
+
+## Contributing
+
+Contributions are always welcome!
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes using [Conventional Commits](https://www.conventionalcommits.org/)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+### Development Scripts
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development mode (watch mode)
+bun run dev
+
+# Build the project
+bun run build
+
+# Run tests
+bun test
+
+# Clean build artifacts
+bun run clean
+```
+
+### Release Process
+
+This project uses automated release scripts:
+
+```bash
+# Create a patch release (1.0.0 -> 1.0.1)
+bun run release:patch
+
+# Create a minor release (1.0.0 -> 1.1.0)
+bun run release:minor
+
+# Create a major release (1.0.0 -> 2.0.0)
+bun run release:major
+
+# Create an alpha release (1.0.0 -> 1.0.1-alpha.0)
+bun run release:alpha
+
+# Create a beta release (1.0.0 -> 1.0.1-beta.0)
+bun run release:beta
+```
+
+The release script will:
+- Run tests
+- Build the project
+- Generate changelog from commits
+- Bump version in package.json
+- Create git tag
+- Create GitHub release
+- Publish to npm
+
+For more details, see [scripts/README.md](scripts/README.md).
+
+## License
+
+[MIT](LICENSE) © [Anibal Santos](https://github.com/ansango)

package/dist/__tests__/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/__tests__/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/utils.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/utils.test.js

@@ -0,0 +1,86 @@
+import { test, beforeEach, afterEach, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { LastFmClient } from '../client.js';
+import { buildUrl, buildAuthUrl } from '../utils.js';
+/**
+ * Regression tests for issue #58:
+ * `new LastFmClient({ apiKey })` must not throw "Failed to parse URL from
+ * undefined" because `buildUrl` / `buildAuthUrl` default `baseUrl`.
+ */
+/** Minimal fake artist payload that satisfies the Zod schema. */
+const fakeArtistPayload = {
+    artist: {
+        name: 'Radiohead',
+        mbid: 'a74b1b7f-71a5-4011-9441-d0b5e4122711',
+        url: 'https://www.last.fm/music/Radiohead',
+        image: [],
+        streamable: '0',
+        ontour: '0',
+        stats: {
+            listeners: '1',
+            playcount: '1',
+            userplaycount: '0'
+        },
+        similar: { artist: [] },
+        tags: { tag: [] },
+        bio: {
+            published: '2024-01-01',
+            summary: 'Test',
+            content: 'Test'
+        }
+    }
+};
+describe('issue #58: default baseUrl', () => {
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        // Mock fetch so the test does not require a real API key.
+        globalThis.fetch = (async (input) => {
+            const url = typeof input === 'string' ? input : input.toString();
+            // Sanity: a syntactically valid URL must be passed to fetch.
+            // Before the fix this would throw "Failed to parse URL from undefined".
+            new URL(url);
+            return new Response(JSON.stringify(fakeArtistPayload), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' }
+            });
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    test('LastFmClient constructed without baseUrl + getInfo does not throw "Failed to parse URL from undefined"', async () => {
+        const client = new LastFmClient({ apiKey: 'test' });
+        const result = await client.artist.getInfo({ artist: 'Radiohead' });
+        assert.equal(result.artist.name, 'Radiohead');
+    });
+    test('buildUrl defaults baseUrl when config.baseUrl is undefined', () => {
+        const config = { apiKey: 'test' };
+        const url = buildUrl(config, 'artist.getInfo', { artist: 'Radiohead' });
+        assert.match(url, /^https:\/\/ws\.audioscrobbler\.com\/2\.0\/\?/);
+        assert.match(url, /method=artist\.getInfo/);
+        assert.match(url, /api_key=test/);
+        // Must not produce the literal "undefined?..." string that caused the original bug.
+        assert.doesNotMatch(url, /^undefined/);
+    });
+    test('buildAuthUrl defaults baseUrl when config.baseUrl is undefined', () => {
+        const config = { apiKey: 'test', sharedSecret: 'secret' };
+        const url = buildAuthUrl(config, 'track.scrobble', {
+            artist: 'Radiohead',
+            track: 'OK Computer',
+            timestamp: 1,
+            sk: 'session'
+        });
+        assert.match(url, /^https:\/\/ws\.audioscrobbler\.com\/2\.0\/\?/);
+        assert.match(url, /api_sig=[a-f0-9]{32}/);
+        assert.doesNotMatch(url, /^undefined/);
+    });
+    test('buildUrl honours an explicit baseUrl when provided', () => {
+        const config = {
+            apiKey: 'test',
+            baseUrl: 'https://example.test/api/'
+        };
+        const url = buildUrl(config, 'artist.getInfo', { artist: 'X' });
+        assert.match(url, /^https:\/\/example\.test\/api\/\?/);
+    });
+});
+//# sourceMappingURL=utils.test.js.map

package/dist/__tests__/utils.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.js","sourceRoot":"","sources":["../../src/__tests__/utils.test.ts"],"names":[],"mappings":"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"}

package/dist/client.d.ts

@@ -0,0 +1,52 @@
+import type { LastFmConfig } from './config.js';
+import { type UserService, type AlbumService, type ArtistService, type TrackService, type TagService, type ChartService, type GeoService, type LibraryService, type AuthService } from './services/index.js';
+/**
+ * Last.fm API Client
+ *
+ * Universal client for interacting with the Last.fm API.
+ * Works in both Node.js and browser environments.
+ *
+ * @example
+ * ```typescript
+ * // With explicit config
+ * const client = new LastFmClient({
+ *   apiKey: 'YOUR_API_KEY',
+ *   sharedSecret: 'YOUR_SHARED_SECRET'
+ * });
+ *
+ * // Using global config
+ * setGlobalConfig({ apiKey: 'YOUR_API_KEY' });
+ * const client = new LastFmClient();
+ * ```
+ */
+export declare class LastFmClient {
+    readonly user: UserService;
+    readonly album: AlbumService;
+    readonly artist: ArtistService;
+    readonly track: TrackService;
+    readonly tag: TagService;
+    readonly chart: ChartService;
+    readonly geo: GeoService;
+    readonly library: LibraryService;
+    readonly auth: AuthService;
+    private readonly config;
+    constructor(config?: Partial<LastFmConfig>);
+    /**
+     * Get the current configuration (read-only)
+     */
+    getConfig(): Readonly<LastFmConfig>;
+}
+/**
+ * Helper function to create a Last.fm client instance
+ *
+ * @param config - Optional configuration. If not provided, uses global config.
+ * @returns A new LastFmClient instance
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({ apiKey: 'YOUR_API_KEY' });
+ * const info = await client.user.getInfo({ user: 'ansango' });
+ * ```
+ */
+export declare function createClient(config?: Partial<LastFmConfig>): LastFmClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAUN,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY;IACxB,SAAgB,IAAI,EAAE,WAAW,CAAC;IAClC,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,MAAM,EAAE,aAAa,CAAC;IACtC,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,GAAG,EAAE,UAAU,CAAC;IAChC,SAAgB,KAAK,EAAE,YAAY,CAAC;IACpC,SAAgB,GAAG,EAAE,UAAU,CAAC;IAChC,SAAgB,OAAO,EAAE,cAAc,CAAC;IACxC,SAAgB,IAAI,EAAE,WAAW,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAE1B,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC;IAe1C;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,YAAY,CAAC;CAGnC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAEzE"}

package/dist/client.js

@@ -0,0 +1,68 @@
+import { getGlobalConfig, createConfig } from './config.js';
+import { createUserService, createAlbumService, createArtistService, createTrackService, createTagService, createChartService, createGeoService, createLibraryService, createAuthService } from './services/index.js';
+/**
+ * Last.fm API Client
+ *
+ * Universal client for interacting with the Last.fm API.
+ * Works in both Node.js and browser environments.
+ *
+ * @example
+ * ```typescript
+ * // With explicit config
+ * const client = new LastFmClient({
+ *   apiKey: 'YOUR_API_KEY',
+ *   sharedSecret: 'YOUR_SHARED_SECRET'
+ * });
+ *
+ * // Using global config
+ * setGlobalConfig({ apiKey: 'YOUR_API_KEY' });
+ * const client = new LastFmClient();
+ * ```
+ */
+export class LastFmClient {
+    user;
+    album;
+    artist;
+    track;
+    tag;
+    chart;
+    geo;
+    library;
+    auth;
+    config;
+    constructor(config) {
+        this.config = config ? createConfig(config) : getGlobalConfig();
+        // Initialize all services
+        this.user = createUserService(this.config);
+        this.album = createAlbumService(this.config);
+        this.artist = createArtistService(this.config);
+        this.track = createTrackService(this.config);
+        this.tag = createTagService(this.config);
+        this.chart = createChartService(this.config);
+        this.geo = createGeoService(this.config);
+        this.library = createLibraryService(this.config);
+        this.auth = createAuthService(this.config);
+    }
+    /**
+     * Get the current configuration (read-only)
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+/**
+ * Helper function to create a Last.fm client instance
+ *
+ * @param config - Optional configuration. If not provided, uses global config.
+ * @returns A new LastFmClient instance
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({ apiKey: 'YOUR_API_KEY' });
+ * const info = await client.user.getInfo({ user: 'ansango' });
+ * ```
+ */
+export function createClient(config) {
+    return new LastFmClient(config);
+}
+//# sourceMappingURL=client.js.map