playlist-data-engine 1.6.0 → 1.7.1

package/dist/gateway-DYTdioNs.js

@@ -0,0 +1,677 @@
+import "./arweaveGatewayManager-DDSO5sLJ.js";
+class n {
+  /**
+   * Extract primary (compressed) audio URL with priority:
+   * 1. mp3_url (Standard web audio - preferred)
+   * 2. lossy_audio (Compressed)
+   * 3. audio_url (Explicit audio field)
+   * 4. audio (Bare audio field — some platforms use this instead of audio_url)
+   * 5. lossless_audio (High fidelity - larger files)
+   * 6. animation_url (OpenSea standard - often audio, but could be video)
+   * 7. multimedia_url (Alternative media field)
+   */
+  static extractAudioUrl(t) {
+    const e = ["mp3_url", "mp3Url", "lossy_audio", "lossyAudio", "audio_url", "audioUrl", "audio", "lossless_audio", "losslessAudio", "animation_url", "animationUrl", "multimedia_url", "multimediaUrl"];
+    for (const r of e)
+      if (t[r] && typeof t[r] == "string")
+        return t[r];
+    return null;
+  }
+  /**
+   * Extract the highest-fidelity audio URL the track offers — best
+   * available, not a guarantee. A track whose only source is an mp3 gets
+   * that back rather than null.
+   */
+  static extractAudioUrlLossless(t) {
+    const e = ["lossless_audio", "losslessAudio", "wav_url", "wavUrl", "flac_url", "flacUrl", "audio_url", "audioUrl"];
+    for (const r of e)
+      if (t[r] && typeof t[r] == "string")
+        return t[r];
+    return null;
+  }
+  /**
+   * Extract image URL with priority:
+   *
+   * Flat fields:
+   * 1. image_small (Preferred for performance)
+   * 2. image (Standard)
+   * 3. image_url (Explicit image URL variant)
+   * 4. image_large (Fallback)
+   * 5. image_uri (URI variant)
+   * 6. image_preview (Preview variant)
+   * 7. image_thumb (Last resort)
+   *
+   * Nested object fields (checked if no flat match found):
+   * 8. artwork.uri (Nina Protocol structured artwork)
+   * 9. project.artwork.uri (Project-level artwork)
+   * 10. primaryMedia.uri (Primary media field)
+   */
+  static extractImageUrl(t) {
+    const e = ["image_small", "imageSmall", "image", "image_large", "imageLarge", "image_thumb", "imageThumb", "image_url", "imageUrl", "image_uri", "imageUri", "image_preview", "imagePreview"];
+    for (const s of e)
+      if (t[s] && typeof t[s] == "string")
+        return t[s];
+    const r = [
+      this.extractNestedUri(t, "artwork", "uri"),
+      this.extractNestedUri(t, "project", "artwork", "uri"),
+      this.extractNestedUri(t, "primaryMedia", "uri")
+    ];
+    for (const s of r)
+      if (s) return s;
+    return null;
+  }
+  /**
+   * Extract thumbnail image URL directly from image_thumb fields.
+   * Unlike extractImageUrl, this specifically targets thumbnail fields only.
+   * Priority: image_thumb_url > image_thumb
+   */
+  static extractImageThumbUrl(t) {
+    return t.image_thumb_url && typeof t.image_thumb_url == "string" ? t.image_thumb_url : t.image_thumb && typeof t.image_thumb == "string" ? t.image_thumb : null;
+  }
+  /**
+   * Extract name/title with priority (see specs/001-core-engine/SPEC.md):
+   * 1. name
+   * 2. title
+   */
+  static extractTitle(t) {
+    return t.name && typeof t.name == "string" ? t.name : t.title && typeof t.title == "string" ? t.title : null;
+  }
+  /**
+   * Extract artist with priority (see specs/001-core-engine/SPEC.md):
+   * 1. artist
+   * 2. created_by
+   * 3. minter
+   * 4. OpenSea-style attributes array with trait_type "Artist"
+   */
+  static extractArtist(t) {
+    const e = ["artist", "artist_name", "artistName", "album_artist", "albumArtist", "created_by", "createdBy", "minter"];
+    for (const r of e)
+      if (t[r] && typeof t[r] == "string")
+        return t[r];
+    if (Array.isArray(t.attributes)) {
+      const r = t.attributes.find(
+        (s) => s.trait_type?.toLowerCase() === "artist" && s.value !== void 0
+      );
+      if (r && typeof r.value == "string")
+        return r.value;
+    }
+    return null;
+  }
+  /**
+   * Parse metadata string to JSON object
+   * Handles stringified JSON with error handling
+   */
+  static parseMetadata(t) {
+    if (!t)
+      return null;
+    if (typeof t == "object" && !Array.isArray(t))
+      return t;
+    if (typeof t == "string")
+      try {
+        const e = JSON.parse(t);
+        if (typeof e == "object" && !Array.isArray(e))
+          return e;
+      } catch (e) {
+        return console.warn("Failed to parse metadata:", e), null;
+      }
+    return null;
+  }
+  /**
+   * Extract genre with support for string or array formats.
+   * Sources are checked in priority order; first non-empty wins:
+   * - `genre` field as a string
+   * - `genre` field as an array (first element)
+   * - OpenSea `attributes` array with `trait_type` of "genre" (case-insensitive)
+   * - `attributes` as an object keyed by trait name (e.g. `attributes.Genre`)
+   * - malformed `attribute ` key (literal trailing space) with `.genre`
+   * Stays strict: only fields literally named "genre" are considered
+   * (no fallback to `category` or similar).
+   */
+  static extractGenre(t) {
+    if (typeof t.genre == "string")
+      return t.genre;
+    if (Array.isArray(t.genre) && t.genre.length > 0) {
+      const r = t.genre[0];
+      return typeof r == "string" ? r : "";
+    }
+    if (Array.isArray(t.attributes)) {
+      const r = t.attributes.find(
+        (s) => s.trait_type?.toLowerCase() === "genre" && s.value !== void 0
+      );
+      if (r) {
+        if (typeof r.value == "string")
+          return r.value;
+        if (Array.isArray(r.value) && r.value.length > 0) {
+          const s = r.value[0];
+          return typeof s == "string" ? s : "";
+        }
+      }
+    }
+    if (t.attributes && typeof t.attributes == "object" && !Array.isArray(t.attributes)) {
+      const r = t.attributes;
+      for (const s of Object.keys(r))
+        if (s.toLowerCase() === "genre" && typeof r[s] == "string")
+          return r[s];
+    }
+    const e = t["attribute "];
+    if (e && typeof e == "object" && !Array.isArray(e)) {
+      const r = e.genre;
+      if (typeof r == "string")
+        return r;
+    }
+    return "";
+  }
+  /**
+   * Extract tags from track metadata, normalized to a deduped,
+   * lowercased, trimmed string[] with empties removed.
+   * Sources (concatenated, then deduped):
+   * - `tags` field as an array, or a single comma-separated string
+   * - `properties.tags` array (when `properties` is an object)
+   * - OpenSea `attributes` array with `trait_type` of "tag"/"tags" (case-insensitive)
+   * - `attributes` as an object keyed by trait name (e.g. `attributes.Tags`)
+   */
+  static extractTags(t) {
+    const e = [];
+    if (Array.isArray(t.tags) ? e.push(...t.tags) : typeof t.tags == "string" && e.push(...t.tags.split(",")), t.properties && typeof t.properties == "object" && !Array.isArray(t.properties)) {
+      const r = t.properties.tags;
+      Array.isArray(r) ? e.push(...r) : typeof r == "string" && e.push(...r.split(","));
+    }
+    if (Array.isArray(t.attributes))
+      for (const r of t.attributes) {
+        if (!r || typeof r != "object") continue;
+        const s = r.trait_type;
+        if (typeof s == "string" && s.toLowerCase().match(/^tags?$/)) {
+          const o = r.value;
+          Array.isArray(o) ? e.push(...o) : typeof o == "string" && e.push(...o.split(","));
+        }
+      }
+    else if (t.attributes && typeof t.attributes == "object") {
+      const r = t.attributes;
+      for (const s of Object.keys(r))
+        if (s.toLowerCase().match(/^tags?$/)) {
+          const o = r[s];
+          Array.isArray(o) ? e.push(...o) : typeof o == "string" && e.push(...o.split(","));
+        }
+    }
+    return n.normalizeTags(e);
+  }
+  /**
+   * Extract track description with priority:
+   *
+   * Flat fields:
+   * 1. description (Canonical)
+   * 2. track_description / trackDescription (Explicit track-scoped variants)
+   * 3. description_text / descriptionText (Text-suffixed variants)
+   * 4. desc / blurb (Short-form variants)
+   *
+   * Then:
+   * 5. OpenSea-style attributes array with trait_type "description" (case-insensitive)
+   * 6. Deep search fallback — breadth-first walk of nested objects for the
+   *    shallowest key matching /description/i (catches properties.description
+   *    and any other nested home for the field). Arrays are skipped: items
+   *    inside arrays (stems, mixes, attribute entries) carry their own scoped
+   *    descriptions, not the track's.
+   */
+  static extractDescription(t) {
+    const e = ["description", "track_description", "trackDescription", "description_text", "descriptionText", "desc", "blurb"];
+    for (const r of e)
+      if (t[r] && typeof t[r] == "string")
+        return t[r];
+    if (Array.isArray(t.attributes)) {
+      const r = t.attributes.find(
+        (s) => s.trait_type?.toLowerCase() === "description" && typeof s.value == "string"
+      );
+      if (r && typeof r.value == "string")
+        return r.value;
+    }
+    return n.deepFindString(t, /description/i);
+  }
+  /**
+   * Extract album description — one of the bonus flavors. Priority:
+   *
+   * Flat fields:
+   * 1. album_description (Canonical)
+   * 2. albumDescription (camelCase variant)
+   *
+   * Nested object fields (only when `album` is an object — it is just as
+   * often a plain name string, which yields nothing here):
+   * 3. Deep search scoped to the album object — catches album.description,
+   *    album.liner_notes, album.notes and friends without ever misattributing
+   *    the track's own description to the album.
+   */
+  static extractAlbumDescription(t) {
+    const e = ["album_description", "albumDescription"];
+    for (const s of e)
+      if (t[s] && typeof t[s] == "string")
+        return t[s];
+    const r = t.album;
+    return r && typeof r == "object" && !Array.isArray(r) ? n.deepFindString(r, /description|liner|notes/i) : null;
+  }
+  /**
+   * Extract artist description — one of the bonus flavors. Priority:
+   *
+   * Flat fields:
+   * 1. artist_description (Canonical)
+   * 2. artistDescription (camelCase variant)
+   * 3. artist_bio / artistBio (Bio variants)
+   *
+   * Nested object fields (only when `artist` is an object — it is just as
+   * often a plain name string, which yields nothing here):
+   * 4. Deep search scoped to the artist object — catches artist.description,
+   *    artist.bio, artist.about and friends without ever misattributing the
+   *    track's own description to the artist.
+   */
+  static extractArtistDescription(t) {
+    const e = ["artist_description", "artistDescription", "artist_bio", "artistBio"];
+    for (const s of e)
+      if (t[s] && typeof t[s] == "string")
+        return t[s];
+    const r = t.artist;
+    return r && typeof r == "object" && !Array.isArray(r) ? n.deepFindString(r, /description|bio|about/i) : null;
+  }
+  /**
+   * Breadth-first search for the shallowest string value whose key matches
+   * the given pattern. First match in breadth order wins: shallowest level,
+   * then key order. Objects are descended (arrays skipped), depth-capped so
+   * pathological metadata blobs stay cheap.
+   */
+  static deepFindString(t, e, r = 5) {
+    const s = /* @__PURE__ */ new Set(), o = [{ node: t, depth: 0 }];
+    for (; o.length > 0; ) {
+      const { node: u, depth: c } = o.shift();
+      for (const f of Object.keys(u)) {
+        const a = u[f];
+        if (typeof a == "string" && a && e.test(f))
+          return a;
+      }
+      if (!(c >= r))
+        for (const f of Object.keys(u)) {
+          const a = u[f];
+          a && typeof a == "object" && !Array.isArray(a) && !s.has(a) && (s.add(a), o.push({ node: a, depth: c + 1 }));
+        }
+    }
+    return null;
+  }
+  /**
+   * Normalize a list of raw tag values into a deduped, lowercased,
+   * trimmed string[] with empties removed.
+   */
+  static normalizeTags(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const r of t) {
+      if (r == null) continue;
+      const s = String(r).trim().toLowerCase();
+      s && e.add(s);
+    }
+    return Array.from(e);
+  }
+  static convertAttributes(t) {
+    if (!Array.isArray(t))
+      return null;
+    const e = {};
+    for (const r of t)
+      r.trait_type && r.value !== void 0 && (e[r.trait_type] = r.value);
+    return Object.keys(e).length > 0 ? e : null;
+  }
+  /**
+   * Safely extract a URI string from a nested object path.
+   * e.g. extractNestedUri(data, 'project', 'artwork', 'uri') => data.project.artwork.uri
+   */
+  static extractNestedUri(t, ...e) {
+    let r = t;
+    for (const s of e)
+      if (r && typeof r == "object" && !Array.isArray(r))
+        r = r[s];
+      else
+        return null;
+    return typeof r == "string" ? r : null;
+  }
+}
+function g(i) {
+  if ("audio_url" in i && typeof i.audio_url == "string")
+    return i.audio_url;
+  if ("metadata" in i) {
+    const t = n.parseMetadata(i.metadata);
+    if (t)
+      return n.extractAudioUrl(t);
+  }
+  return null;
+}
+function A(i) {
+  if ("audio_url_lossless" in i && typeof i.audio_url_lossless == "string")
+    return i.audio_url_lossless;
+  if ("metadata" in i) {
+    const t = n.parseMetadata(i.metadata);
+    if (t)
+      return n.extractAudioUrlLossless(t);
+  }
+  return null;
+}
+function d(i) {
+  if ("image_url" in i && typeof i.image_url == "string")
+    return i.image_url;
+  if ("metadata" in i) {
+    if ("artwork_url" in i && typeof i.artwork_url == "string")
+      return i.artwork_url;
+    const t = n.parseMetadata(i.metadata);
+    if (t)
+      return n.extractImageUrl(t);
+  }
+  return null;
+}
+function _(i) {
+  if ("image_thumb_url" in i && typeof i.image_thumb_url == "string")
+    return i.image_thumb_url;
+  if ("metadata" in i) {
+    const t = n.parseMetadata(i.metadata);
+    if (t)
+      return n.extractImageThumbUrl(t);
+  }
+  return null;
+}
+function h(i) {
+  if ("metadata" in i) {
+    const t = n.parseMetadata(i.metadata);
+    if (t && typeof t.vrm == "string" && t.vrm)
+      return t.vrm;
+  }
+  return "extras" in i && i.extras && typeof i.extras.vrm == "string" && i.extras.vrm || null;
+}
+function M(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    const r = g(e);
+    r && t.push(r);
+  }
+  return t;
+}
+function j(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    const r = d(e);
+    r && t.push(r);
+  }
+  return t;
+}
+function F(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    if ("title" in e && typeof e.title == "string") {
+      t.push(e.title);
+      continue;
+    }
+    if ("metadata" in e) {
+      const r = n.parseMetadata(e.metadata);
+      if (r) {
+        const s = n.extractTitle(r);
+        s && t.push(s);
+      }
+    }
+  }
+  return t;
+}
+function $(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    if ("artist" in e && typeof e.artist == "string") {
+      t.push(e.artist);
+      continue;
+    }
+    if ("metadata" in e) {
+      const r = n.parseMetadata(e.metadata);
+      if (r) {
+        const s = n.extractArtist(r);
+        s && t.push(s);
+      }
+    }
+  }
+  return t;
+}
+function D(i) {
+  const t = /* @__PURE__ */ new Set();
+  for (const e of i.tracks) {
+    if ("genre" in e && typeof e.genre == "string" && e.genre) {
+      t.add(e.genre);
+      continue;
+    }
+    if ("metadata" in e) {
+      const r = n.parseMetadata(e.metadata);
+      r && typeof r.genre == "string" && r.genre && t.add(r.genre);
+    }
+  }
+  return Array.from(t).sort();
+}
+function I(i) {
+  const t = /* @__PURE__ */ new Set();
+  for (const e of i.tracks) {
+    if ("tags" in e && Array.isArray(e.tags)) {
+      for (const r of e.tags)
+        r && t.add(r.toLowerCase());
+      continue;
+    }
+    if ("metadata" in e) {
+      const r = n.parseMetadata(e.metadata);
+      if (r && Array.isArray(r.tags))
+        for (const s of r.tags)
+          s && t.add(String(s).toLowerCase());
+    }
+  }
+  return Array.from(t).sort();
+}
+function C(i) {
+  let t = 0;
+  for (const e of i.tracks) {
+    if ("duration" in e && typeof e.duration == "number") {
+      t += e.duration;
+      continue;
+    }
+    if ("metadata" in e) {
+      const r = n.parseMetadata(e.metadata);
+      r && typeof r.duration == "number" && (t += r.duration);
+    }
+  }
+  return t;
+}
+function H(i) {
+  return i.tracks.length;
+}
+function P(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    const r = g(e), s = d(e), o = _(e);
+    let u = "", c = "", f;
+    if ("title" in e)
+      u = e.title || "", c = e.artist || "", f = e.description || void 0;
+    else if ("metadata" in e) {
+      const a = n.parseMetadata(e.metadata);
+      a && (u = n.extractTitle(a) || "", c = n.extractArtist(a) || "", f = n.extractDescription(a) || void 0);
+    }
+    if (r) {
+      const a = {
+        title: u,
+        artist: c,
+        audio_url: r,
+        image_url: s || ""
+      }, l = A(e);
+      l && l !== r && (a.audio_url_lossless = l), o && (a.image_thumb_url = o), f && (a.description = f), "audio_ipfs_hash" in e && typeof e.audio_ipfs_hash == "string" && (a.audio_ipfs_hash = e.audio_ipfs_hash), "artwork_ipfs_hash" in e && typeof e.artwork_ipfs_hash == "string" && (a.artwork_ipfs_hash = e.artwork_ipfs_hash), t.push(a);
+    }
+  }
+  return t;
+}
+function W(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    if ("audio_url" in e) {
+      t.push({ ...e });
+      continue;
+    }
+    if ("metadata" in e) {
+      const r = n.parseMetadata(e.metadata);
+      if (r) {
+        const s = n.extractAudioUrlLossless(r), o = n.extractAudioUrl(r);
+        t.push({
+          id: e.chain_name === "AR" ? `AR-${e.tx_id}` : `${e.chain_name}-${e.token_address}-${e.token_id}`,
+          chain_name: e.chain_name,
+          token_address: e.token_address,
+          token_id: e.token_id,
+          tx_id: e.tx_id,
+          platform: e.platform,
+          title: n.extractTitle(r),
+          artist: n.extractArtist(r),
+          audio_url: o,
+          image_url: n.extractImageUrl(r),
+          image_thumb_url: n.extractImageThumbUrl(r),
+          duration: r.duration,
+          genre: r.genre,
+          tags: r.tags,
+          bpm: r.bpm,
+          key: r.key,
+          album: r.album,
+          description: n.extractDescription(r),
+          attributes: n.convertAttributes(r.attributes),
+          ...s && s !== o ? { audio_url_lossless: s } : {},
+          // v0.4 IPFS hash fields from raw track (mint fields live only in metadata interior)
+          ...e.audio_ipfs_hash ? { audio_ipfs_hash: e.audio_ipfs_hash } : {},
+          ...e.artwork_ipfs_hash ? { artwork_ipfs_hash: e.artwork_ipfs_hash } : {}
+        });
+      }
+    }
+  }
+  return t;
+}
+function E(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    const r = h(e);
+    r && t.push(r);
+  }
+  return t;
+}
+function N(i) {
+  const t = [];
+  for (const e of i.tracks) {
+    const r = h(e);
+    if (!r) continue;
+    const s = g(e), o = d(e), u = _(e);
+    let c = "", f = "", a;
+    if ("title" in e)
+      c = e.title || "", f = e.artist || "", a = e.description || void 0;
+    else if ("metadata" in e) {
+      const p = n.parseMetadata(e.metadata);
+      p && (c = n.extractTitle(p) || "", f = n.extractArtist(p) || "", a = n.extractDescription(p) || void 0);
+    }
+    const l = {
+      title: c,
+      artist: f,
+      audio_url: s || "",
+      image_url: o || "",
+      vrm: r
+    };
+    u && (l.image_thumb_url = u), a && (l.description = a), t.push(l);
+  }
+  return t;
+}
+const y = [
+  "ipfs.io",
+  "cloudflare-ipfs.com",
+  "dweb.link",
+  "gateway.pinata.cloud",
+  "ipfs.infura.io",
+  "nftstorage.link",
+  "web3-music-pipeline.mypinata.cloud",
+  "soundxyz.mypinata.cloud",
+  "gold-broad-gibbon-29.mypinata.cloud",
+  "bonfire.mypinata.cloud",
+  "spinamp.mypinata.cloud",
+  "catalogworks.b-cdn.net",
+  "www.heds.cloud"
+], k = "ipfs.io", m = "/ipfs/", w = /^Qm[1-9A-HJ-NP-Za-km-z]{44}$/, x = /^b[a-z2-7]{55,}$/;
+function v(i) {
+  return w.test(i) || x.test(i);
+}
+const T = /^ipfs_[a-z]+$/;
+function b(i) {
+  const t = i.split("/").filter(Boolean);
+  for (let e = 0; e < t.length - 1; e++)
+    if (T.test(t[e]) && v(t[e + 1])) {
+      const r = t[e + 1], s = t.slice(e + 2);
+      return s.length > 0 ? `${r}/${s.join("/")}` : r;
+    }
+  return null;
+}
+function U(i) {
+  if (!i || typeof i != "string") return null;
+  if (i.startsWith("ipfs://ipfs/"))
+    return i.slice(12);
+  if (i.startsWith("ipfs://"))
+    return i.slice(7);
+  try {
+    const t = new URL(i), { hostname: e, pathname: r } = t, s = e.match(/^([A-Za-z0-9]+)\.ipfs\.dweb\.link$/);
+    if (s)
+      return `${s[1]}${r}`;
+    if (y.some(
+      (c) => e === c || e.endsWith("." + c)
+    ) && r.startsWith(m))
+      return r.slice(m.length);
+    const u = b(r);
+    if (u) return u;
+  } catch {
+  }
+  return null;
+}
+function R(i) {
+  if (!i || typeof i != "string") return !1;
+  if (i.startsWith("ipfs://")) return !0;
+  try {
+    const t = new URL(i), { hostname: e, pathname: r } = t;
+    if (/^[A-Za-z0-9]+\.ipfs\.dweb\.link$/.test(e) || y.some(
+      (o) => e === o || e.endsWith("." + o)
+    ) && r.startsWith(m) || b(r)) return !0;
+  } catch {
+  }
+  return !1;
+}
+function S(i) {
+  if (!(!i || i.startsWith("ipfs://")))
+    try {
+      const { hostname: t } = new URL(i);
+      return y.some(
+        (r) => t === r || t.endsWith("." + r)
+      ) ? t : void 0;
+    } catch {
+      return;
+    }
+}
+function G(i, t = {}) {
+  if (!i) return i;
+  const e = typeof t == "string" ? { gatewayHost: t } : t, { gatewayHost: r = k, preserveOriginalGateway: s = !1 } = e, o = U(i);
+  if (o) {
+    if (s) {
+      const u = S(i);
+      if (u)
+        return `https://${u}/ipfs/${o}`;
+    }
+    return `https://${r}/ipfs/${o}`;
+  }
+  return i;
+}
+export {
+  k as D,
+  y as K,
+  n as M,
+  M as a,
+  W as b,
+  D as c,
+  j as d,
+  U as e,
+  I as f,
+  $ as g,
+  C as h,
+  H as i,
+  F as j,
+  P as k,
+  N as l,
+  E as m,
+  R as n,
+  G as r
+};