@audd/sdk 1.4.7 → 1.5.0

package/dist/longpoll.d.cts

@@ -1,4 +1,4 @@
-import { F as FetchLike } from './http-y2YwjfAl.cjs';
+import { F as FetchLike, L as LongpollPoll } from './longpollCore-DMBdcGSM.cjs';
 
 /**
  * Tokenless longpoll consumer for browser/widget/extension use cases.
@@ -9,11 +9,12 @@ import { F as FetchLike } from './http-y2YwjfAl.cjs';
  * token).
  *
  * Behavior:
- * - HTTP non-2xx → throws `AudDServerError` (no silent infinite loop)
- * - JSON decode failure on 2xx → throws `AudDSerializationError`
+ * - HTTP non-2xx → terminal {@link AudDServerError} on the `errors` iterable
+ *   (no silent infinite loop).
+ * - JSON decode failure on 2xx → terminal {@link AudDSerializationError}.
  * - READ-class retries on 5xx + connection failures, configurable via
- *   `maxRetries` / `backoffFactorMs`
- * - `[Symbol.asyncDispose]()` + manual `close()` for resource cleanup
+ *   `maxRetries` / `backoffFactorMs`.
+ * - `[Symbol.asyncDispose]()` + manual `close()` for resource cleanup.
  *
  * Imported from `audd/longpoll` (browser-safe sub-entry, NOT the main
  * `audd` module — bundlers tree-shake the auth client out).
@@ -33,26 +34,36 @@ interface IterateOptions {
     timeout?: number;
 }
 /**
- * Tokenless async longpoll consumer.
+ * Tokenless longpoll consumer.
  *
  * ```ts
  * import { LongpollConsumer } from 'audd/longpoll';
  *
  * const consumer = new LongpollConsumer("abc123def");
- * for await (const event of consumer.iterate({ timeout: 30 })) {
- *   console.log(event);
+ * const poll = consumer.iterate({ timeout: 30 });
+ * for await (const m of poll.matches) {
+ *   console.log(m.song.artist, m.song.title);
  * }
  * ```
+ *
+ * Or iterate matches and notifications concurrently:
+ *
+ * ```ts
+ * await Promise.all([
+ *   (async () => { for await (const m of poll.matches) { ... } })(),
+ *   (async () => { for await (const n of poll.notifications) { ... } })(),
+ * ]);
+ * ```
  */
 declare class LongpollConsumer {
     readonly category: string;
     private readonly fetchImpl;
     private readonly policy;
     constructor(category: string, opts?: LongpollConsumerOptions);
-    iterate(opts?: IterateOptions): AsyncIterable<Record<string, unknown>>;
+    iterate(opts?: IterateOptions): LongpollPoll;
     /** Release any underlying resources. */
     close(): void;
     [Symbol.asyncDispose](): Promise<void>;
 }
 
-export { type IterateOptions, LongpollConsumer, type LongpollConsumerOptions };
+export { type IterateOptions, LongpollConsumer, type LongpollConsumerOptions, LongpollPoll };

package/dist/longpoll.d.ts

@@ -1,4 +1,4 @@
-import { F as FetchLike } from './http-y2YwjfAl.js';
+import { F as FetchLike, L as LongpollPoll } from './longpollCore-DMBdcGSM.js';
 
 /**
  * Tokenless longpoll consumer for browser/widget/extension use cases.
@@ -9,11 +9,12 @@ import { F as FetchLike } from './http-y2YwjfAl.js';
  * token).
  *
  * Behavior:
- * - HTTP non-2xx → throws `AudDServerError` (no silent infinite loop)
- * - JSON decode failure on 2xx → throws `AudDSerializationError`
+ * - HTTP non-2xx → terminal {@link AudDServerError} on the `errors` iterable
+ *   (no silent infinite loop).
+ * - JSON decode failure on 2xx → terminal {@link AudDSerializationError}.
  * - READ-class retries on 5xx + connection failures, configurable via
- *   `maxRetries` / `backoffFactorMs`
- * - `[Symbol.asyncDispose]()` + manual `close()` for resource cleanup
+ *   `maxRetries` / `backoffFactorMs`.
+ * - `[Symbol.asyncDispose]()` + manual `close()` for resource cleanup.
  *
  * Imported from `audd/longpoll` (browser-safe sub-entry, NOT the main
  * `audd` module — bundlers tree-shake the auth client out).
@@ -33,26 +34,36 @@ interface IterateOptions {
     timeout?: number;
 }
 /**
- * Tokenless async longpoll consumer.
+ * Tokenless longpoll consumer.
  *
  * ```ts
  * import { LongpollConsumer } from 'audd/longpoll';
  *
  * const consumer = new LongpollConsumer("abc123def");
- * for await (const event of consumer.iterate({ timeout: 30 })) {
- *   console.log(event);
+ * const poll = consumer.iterate({ timeout: 30 });
+ * for await (const m of poll.matches) {
+ *   console.log(m.song.artist, m.song.title);
  * }
  * ```
+ *
+ * Or iterate matches and notifications concurrently:
+ *
+ * ```ts
+ * await Promise.all([
+ *   (async () => { for await (const m of poll.matches) { ... } })(),
+ *   (async () => { for await (const n of poll.notifications) { ... } })(),
+ * ]);
+ * ```
  */
 declare class LongpollConsumer {
     readonly category: string;
     private readonly fetchImpl;
     private readonly policy;
     constructor(category: string, opts?: LongpollConsumerOptions);
-    iterate(opts?: IterateOptions): AsyncIterable<Record<string, unknown>>;
+    iterate(opts?: IterateOptions): LongpollPoll;
     /** Release any underlying resources. */
     close(): void;
     [Symbol.asyncDispose](): Promise<void>;
 }
 
-export { type IterateOptions, LongpollConsumer, type LongpollConsumerOptions };
+export { type IterateOptions, LongpollConsumer, type LongpollConsumerOptions, LongpollPoll };

package/dist/longpoll.js

@@ -45,6 +45,272 @@ var AudDSerializationError = class extends AudDError {
   }
 };
 
+// src/models.ts
+function pickExtras(raw, knownKeys) {
+  const known = new Set(knownKeys);
+  const extras = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (!known.has(k)) extras[k] = v;
+  }
+  return extras;
+}
+function asObject(raw) {
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+    return raw;
+  }
+  return void 0;
+}
+function requireObject(raw, what) {
+  const o = asObject(raw);
+  if (o === void 0) throw new TypeError(`${what}: expected object`);
+  return o;
+}
+function asString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function asNumber(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function asBoolean(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+var STREAM_CALLBACK_SONG_KEYS = [
+  "artist",
+  "title",
+  "score",
+  "album",
+  "release_date",
+  "label",
+  "song_link",
+  "isrc",
+  "upc",
+  "apple_music",
+  "spotify",
+  "deezer",
+  "napster",
+  "musicbrainz"
+];
+function parseStreamCallbackSong(raw) {
+  const r = requireObject(raw, "StreamCallbackSong");
+  const artist = asString(r.artist);
+  const title = asString(r.title);
+  const score = asNumber(r.score);
+  if (artist === void 0) throw new TypeError("StreamCallbackSong: artist not string");
+  if (title === void 0) throw new TypeError("StreamCallbackSong: title not string");
+  if (score === void 0) throw new TypeError("StreamCallbackSong: score not number");
+  const musicbrainz = Array.isArray(r.musicbrainz) ? r.musicbrainz.filter((x) => asObject(x) !== void 0) : void 0;
+  return {
+    artist,
+    title,
+    score,
+    album: asString(r.album),
+    releaseDate: asString(r.release_date),
+    label: asString(r.label),
+    songLink: asString(r.song_link),
+    isrc: asString(r.isrc),
+    upc: asString(r.upc),
+    appleMusic: asObject(r.apple_music),
+    spotify: asObject(r.spotify),
+    deezer: asObject(r.deezer),
+    napster: asObject(r.napster),
+    musicbrainz,
+    extras: pickExtras(r, STREAM_CALLBACK_SONG_KEYS)
+  };
+}
+var STREAM_CALLBACK_MATCH_KEYS = [
+  "radio_id",
+  "timestamp",
+  "play_length",
+  "results"
+];
+function parseStreamCallbackMatch(raw) {
+  const r = requireObject(raw, "StreamCallbackMatch");
+  const radioId = asNumber(r.radio_id);
+  if (radioId === void 0) throw new TypeError("StreamCallbackMatch: radio_id not number");
+  const resultsRaw = r.results;
+  if (!Array.isArray(resultsRaw)) throw new TypeError("StreamCallbackMatch: results not array");
+  if (resultsRaw.length === 0) throw new TypeError("StreamCallbackMatch: results is empty");
+  const songs = resultsRaw.map(parseStreamCallbackSong);
+  const [first, ...rest] = songs;
+  if (first === void 0) throw new TypeError("StreamCallbackMatch: results is empty");
+  return {
+    radioId,
+    timestamp: asString(r.timestamp),
+    playLength: asNumber(r.play_length),
+    song: first,
+    alternatives: rest,
+    extras: pickExtras(r, STREAM_CALLBACK_MATCH_KEYS),
+    rawResponse: r
+  };
+}
+var STREAM_CALLBACK_NOTIFICATION_KEYS = [
+  "radio_id",
+  "stream_running",
+  "notification_code",
+  "notification_message"
+];
+function parseStreamCallbackNotification(raw) {
+  const r = requireObject(raw, "StreamCallbackNotification");
+  const radioId = asNumber(r.radio_id);
+  if (radioId === void 0)
+    throw new TypeError("StreamCallbackNotification: radio_id not number");
+  const code = asNumber(r.notification_code);
+  if (code === void 0)
+    throw new TypeError("StreamCallbackNotification: notification_code not number");
+  const message = asString(r.notification_message);
+  if (message === void 0)
+    throw new TypeError("StreamCallbackNotification: notification_message not string");
+  return {
+    radioId,
+    streamRunning: asBoolean(r.stream_running),
+    notificationCode: code,
+    notificationMessage: message,
+    extras: pickExtras(r, STREAM_CALLBACK_NOTIFICATION_KEYS),
+    rawResponse: r
+  };
+}
+
+// src/longpollCore.ts
+var HTTP_CLIENT_ERROR_FLOOR = 400;
+var AsyncQueue = class {
+  items = [];
+  waiters = [];
+  done = false;
+  push(value) {
+    if (this.done) return;
+    const w = this.waiters.shift();
+    if (w !== void 0) {
+      w({ value, done: false });
+      return;
+    }
+    this.items.push(value);
+  }
+  finish() {
+    if (this.done) return;
+    this.done = true;
+    while (this.waiters.length > 0) {
+      const w = this.waiters.shift();
+      if (w !== void 0) w({ value: void 0, done: true });
+    }
+  }
+  next() {
+    const item = this.items.shift();
+    if (item !== void 0) return Promise.resolve({ value: item, done: false });
+    if (this.done) return Promise.resolve({ value: void 0, done: true });
+    return new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+  toIterable() {
+    const next = () => this.next();
+    return {
+      [Symbol.asyncIterator]() {
+        return { next };
+      }
+    };
+  }
+};
+function decodeOne(resp) {
+  if (resp.httpStatus >= HTTP_CLIENT_ERROR_FLOOR) {
+    throw new AudDServerError({
+      errorCode: 0,
+      message: `Longpoll endpoint returned HTTP ${String(resp.httpStatus)}`,
+      httpStatus: resp.httpStatus,
+      requestId: resp.requestId,
+      rawResponse: resp.jsonBody ?? resp.rawText
+    });
+  }
+  const body = resp.jsonBody;
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    throw new AudDSerializationError(
+      "Longpoll response was not a JSON object",
+      resp.rawText
+    );
+  }
+  const dict = body;
+  if ("notification" in dict) {
+    const notification = parseStreamCallbackNotification(dict.notification);
+    const t = dict["time"];
+    if (typeof t === "number") notification.time = t;
+    return { kind: "notification", notification };
+  }
+  if ("result" in dict) {
+    return { kind: "match", match: parseStreamCallbackMatch(dict.result) };
+  }
+  return { kind: "keepalive" };
+}
+function startLongpoll(cfg) {
+  const matches = new AsyncQueue();
+  const notifications = new AsyncQueue();
+  const errors = new AsyncQueue();
+  const controller = new AbortController();
+  let closed = false;
+  const finishAll = () => {
+    matches.finish();
+    notifications.finish();
+    errors.finish();
+  };
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    controller.abort();
+    finishAll();
+  };
+  const run = async () => {
+    let curSince = cfg.sinceTime;
+    while (!closed) {
+      const params = {
+        category: cfg.category,
+        timeout: String(cfg.timeout)
+      };
+      if (curSince !== void 0) params["since_time"] = String(curSince);
+      let resp;
+      try {
+        resp = await cfg.fetchOnce(params, controller.signal);
+      } catch (err) {
+        if (closed) return;
+        if (err instanceof TypeError) {
+          errors.push(new AudDConnectionError(`Network error: ${err.message}`, err));
+        } else if (err !== null && typeof err === "object" && err.name === "AbortError") {
+          if (closed) return;
+          errors.push(new AudDConnectionError("Request was aborted (timeout)", err));
+        } else if (err instanceof Error) {
+          errors.push(err);
+        } else {
+          errors.push(new Error(String(err)));
+        }
+        finishAll();
+        return;
+      }
+      try {
+        const decoded = decodeOne(resp);
+        if (decoded.kind === "match") matches.push(decoded.match);
+        else if (decoded.kind === "notification") notifications.push(decoded.notification);
+      } catch (err) {
+        errors.push(err instanceof Error ? err : new Error(String(err)));
+        finishAll();
+        return;
+      }
+      const dict = resp.jsonBody;
+      if (typeof dict === "object" && dict !== null && !Array.isArray(dict)) {
+        const ts = dict["timestamp"];
+        if (typeof ts === "number") curSince = ts;
+      }
+    }
+  };
+  void run();
+  return {
+    matches: matches.toIterable(),
+    notifications: notifications.toIterable(),
+    errors: errors.toIterable(),
+    close,
+    async [Symbol.asyncDispose]() {
+      close();
+      await Promise.resolve();
+    }
+  };
+}
+
 // src/retry.ts
 var DEFAULT_BACKOFF_FACTOR_MS = 500;
 var DEFAULT_BACKOFF_MAX_MS = 3e4;
@@ -133,23 +399,6 @@ function userAgent() {
 
 // src/longpoll.ts
 var LONGPOLL_URL = "https://api.audd.io/longpoll/";
-var HTTP_CLIENT_ERROR_FLOOR = 400;
-var DEFAULT_TIMEOUT_MS = 12e4;
-function decode(jsonBody, httpStatus, rawText) {
-  if (httpStatus >= HTTP_CLIENT_ERROR_FLOOR) {
-    throw new AudDServerError({
-      errorCode: 0,
-      message: `Longpoll endpoint returned HTTP ${String(httpStatus)}`,
-      httpStatus,
-      requestId: null,
-      rawResponse: jsonBody ?? rawText
-    });
-  }
-  if (typeof jsonBody !== "object" || jsonBody === null || Array.isArray(jsonBody)) {
-    throw new AudDSerializationError("Longpoll response was not a JSON object", rawText);
-  }
-  return jsonBody;
-}
 var LongpollConsumer = class {
   constructor(category, opts = {}) {
     this.category = category;
@@ -165,70 +414,54 @@ var LongpollConsumer = class {
   fetchImpl;
   policy;
   iterate(opts = {}) {
-    const category = this.category;
-    const policy = this.policy;
     const fetchImpl = this.fetchImpl;
-    const initialSince = opts.sinceTime;
+    const policy = this.policy;
     const timeoutSec = opts.timeout ?? 50;
-    async function fetchOnce(curSince) {
+    const fetchOnceRaw = async (params, signal) => {
       const u = new URL(LONGPOLL_URL);
-      u.searchParams.set("category", category);
-      u.searchParams.set("timeout", String(timeoutSec));
-      if (curSince !== void 0) u.searchParams.set("since_time", String(curSince));
-      const controller = new AbortController();
-      const timer = setTimeout(() => {
-        controller.abort();
-      }, DEFAULT_TIMEOUT_MS);
-      try {
-        const response = await fetchImpl(u.toString(), {
-          method: "GET",
-          headers: { "User-Agent": userAgent() },
-          signal: controller.signal
-        });
-        const text = await response.text();
-        let json = null;
-        if (text !== "") {
-          try {
-            json = JSON.parse(text);
-          } catch {
-            json = null;
-          }
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== void 0) u.searchParams.set(k, v);
+      }
+      const response = await fetchImpl(u.toString(), {
+        method: "GET",
+        headers: { "User-Agent": userAgent() },
+        signal
+      });
+      const text = await response.text();
+      let json = null;
+      if (text !== "") {
+        try {
+          json = JSON.parse(text);
+        } catch {
+          json = null;
         }
-        return {
-          jsonBody: json,
-          httpStatus: response.status,
-          requestId: response.headers.get("x-request-id"),
-          rawText: text
-        };
-      } finally {
-        clearTimeout(timer);
       }
-    }
-    return {
-      [Symbol.asyncIterator]() {
-        let curSince = initialSince;
-        return {
-          async next() {
-            let resp;
-            try {
-              resp = await retry(() => fetchOnce(curSince), policy);
-            } catch (err) {
-              if (err instanceof TypeError) {
-                throw new AudDConnectionError(`Network error: ${err.message}`, err);
-              }
-              if (err !== null && typeof err === "object" && err.name === "AbortError") {
-                throw new AudDConnectionError("Request was aborted (timeout)", err);
-              }
-              throw err;
-            }
-            const body = decode(resp.jsonBody, resp.httpStatus, resp.rawText);
-            const ts = body["timestamp"];
-            if (typeof ts === "number") curSince = ts;
-            return { value: body, done: false };
-          }
-        };
+      return {
+        jsonBody: json,
+        httpStatus: response.status,
+        requestId: response.headers.get("x-request-id"),
+        rawText: text
+      };
+    };
+    const fetchOnce = async (params, signal) => {
+      try {
+        return await retry(() => fetchOnceRaw(params, signal), policy);
+      } catch (err) {
+        if (err instanceof TypeError) {
+          throw new AudDConnectionError(`Network error: ${err.message}`, err);
+        }
+        if (err !== null && typeof err === "object" && err.name === "AbortError") {
+          throw new AudDConnectionError("Request was aborted (timeout)", err);
+        }
+        throw err;
       }
     };
+    return startLongpoll({
+      category: this.category,
+      timeout: timeoutSec,
+      sinceTime: opts.sinceTime,
+      fetchOnce
+    });
   }
   /** Release any underlying resources. */
   close() {