@rapthi/podca-ts 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Thierry Rapillard
+
+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,269 @@
+# podca-ts
+
+[![npm version](https://badge.fury.io/js/podca-ts.svg)](https://badge.fury.io/js/podca-ts)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org/)
+
+A modern, fully-typed TypeScript library for parsing and managing podcast feeds from RSS/iTunes feeds. Built with type safety, error handling, and comprehensive test coverage.
+
+## Features
+
+- 📡 **Parse RSS Feeds** - Extract podcast metadata from standard RSS feeds
+- 🎵 **iTunes Support** - Full support for iTunes-specific podcast metadata
+- 🔍 **iTunes Search** - Search for podcasts using the iTunes Search API
+- 📦 **Fully Typed** - Complete TypeScript support with strict type checking
+
+## Installation
+
+```bash
+npm install podca-ts
+```
+```bash
+yarn add podca-ts
+```
+```bash
+pnpm add podca-ts
+```
+
+## Quick Start
+
+### Parse a Podcast Feed
+
+```typescript
+import { PodcastLoader } from 'podca-ts';
+
+const loader = new PodcastLoader();
+
+try {
+  const podcast = await loader.getPodcastFromFeed(
+    'https://example.com/podcast/feed.xml'
+  );
+
+  console.log(`Podcast: ${podcast.title}`);
+  console.log(`Episodes: ${podcast.episodes?.length}`);
+  
+  podcast.episodes?.forEach((episode) => {
+    console.log(`- ${episode.title} (${episode.durationInSeconds}s)`);
+  });
+} catch (error) {
+  console.error('Failed to load podcast:', error);
+}
+```
+
+### Search for Podcasts on iTunes
+
+```typescript
+import { ItunesSearch } from 'podca-ts';
+
+const searcher = new ItunesSearch();
+
+try {
+  const results = await searcher.search({
+    term: 'javascript',
+    media: 'podcast',
+    limit: 10,
+    country: 'US',
+  });
+
+  console.log(`Found ${results.resultCount} podcasts`);
+  
+  results.results.forEach((podcast) => {
+    console.log(`- ${podcast.trackName} by ${podcast.artistName}`);
+  });
+} catch (error) {
+  console.error('Search failed:', error);
+}
+```
+
+## API Documentation
+
+### PodcastLoader
+
+The main class for parsing podcast feeds.
+
+#### Constructor
+
+```typescript
+const loader = new PodcastLoader();
+```
+
+#### Methods
+
+##### `getPodcastFromFeed(feedUrl: string): Promise<Podcast>`
+
+Fetches and parses a podcast feed from the given URL.
+
+**Parameters:**
+- `feedUrl` (string): The URL of the podcast RSS feed
+
+**Returns:** A Promise that resolves to a `Podcast` object
+
+**Throws:**
+- `Error` if the feed URL is invalid
+- `Error` if the feed cannot be fetched
+- `Error` if the feed is malformed or missing required fields
+- `Error` if the request times out (30 seconds)
+
+**Example:**
+
+```typescript
+const podcast = await loader.getPodcastFromFeed(
+  'https://feeds.example.com/podcast.xml'
+);
+```
+
+### ItunesSearch
+
+Search for podcasts using the iTunes Search API.
+
+#### Constructor
+
+```typescript
+const searcher = new ItunesSearch();
+```
+
+#### Methods
+
+##### `search<T extends MediaType>(option: ITunesSearchParams<T>): Promise<ITunesSearchResponse>`
+
+Searches for content on iTunes.
+
+**Parameters:**
+- `option` (ITunesSearchParams): Search parameters
+
+**Returns:** A Promise that resolves to an `ITunesSearchResponse` object
+
+**Throws:**
+- `Error` if the API request fails
+- `Error` if the response is not OK
+
+**Example:**
+
+```typescript
+const results = await searcher.search({
+  term: 'typescript',
+  media: 'podcast',
+  limit: 25,
+  country: 'US',
+  lang: 'en_us',
+});
+```
+
+## Types
+
+### Podcast
+
+```typescript
+interface Podcast {
+  title: string;
+  description?: string;
+  link: string;
+  language?: string;
+  categories: Category[];
+  explicit: boolean;
+  imageUrl?: string;
+  author?: string;
+  copyright?: string;
+  fundingUrl?: string;
+  type?: string;
+  episodes?: Episode[];
+}
+```
+
+### Episode
+
+```typescript
+interface Episode {
+  title?: string;
+  guid: string;
+  enclosure?: Enclosure;
+  linkUrl?: string;
+  pubDate?: string;
+  description?: string;
+  durationInSeconds?: string | number;
+  imageUrl?: string;
+  explicit?: boolean;
+  number?: number;
+  season?: number;
+  type?: string;
+}
+```
+
+### Category
+
+```typescript
+interface Category {
+  name: string;
+}
+```
+
+### Enclosure
+
+```typescript
+interface Enclosure {
+  url: string;
+  type: string;
+  length: string;
+}
+```
+
+### ITunesSearchParams
+
+```typescript
+interface ITunesSearchParams<T extends MediaType> {
+  term: string;
+  media: T;
+  entity?: EntityForMediaType<T>;
+  country?: string;
+  limit?: number;
+  lang?: string;
+  version?: number;
+  explicit?: 'Yes' | 'No';
+}
+```
+
+## Error Handling
+
+The library provides detailed error messages to help with debugging:
+
+```typescript
+import { PodcastLoader } from 'podca-ts';
+
+const loader = new PodcastLoader();
+
+try {
+  const podcast = await loader.getPodcastFromFeed('invalid-url');
+} catch (error) {
+  if (error instanceof Error) {
+    console.error(error.message);
+    // Output: "Invalid feed URL: invalid-url"
+  }
+}
+```
+
+## Requirements
+
+- **Node.js**: >= 18.0.0
+- **TypeScript**: >= 5.0.0 (for development)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT © [Thierry Rapillard](https://github.com/rapthi)
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for a list of changes in each release.
+
+## Support
+
+If you encounter any issues or have questions, please open an issue on [GitHub](https://github.com/rapthi/podca-ts/issues).
+
+## Acknowledgments
+
+- Built with [TypeScript](https://www.typescriptlang.org/)
+- Tested with [Vitest](https://vitest.dev/)
+- Parsing powered by [@sesamy/podcast-parser](https://www.npmjs.com/package/@sesamy/podcast-parser)

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './itunes-search/itunes-search-options.js';
+export type * from './itunes-search/itunes-search-result.js';
+export * from './itunes-search/itunes-search.js';
+export * from './podcast/podcast.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,0CAA0C,CAAC;AAC9D,mBAAmB,yCAAyC,CAAC;AAC7D,cAAc,kCAAkC,CAAC;AACjD,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './itunes-search/itunes-search.js';
+export * from './podcast/podcast.js';

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,0CAA0C,CAAC"}

package/dist/itunes-search/iTunesSearch.d.ts

@@ -0,0 +1,6 @@
+import type { ITunesSearchParams, MediaType } from './itunes-search-options.js';
+export declare class iTunesSearch {
+    constructor();
+    search<T extends MediaType>(option: ITunesSearchParams<T>): void;
+}
+//# sourceMappingURL=iTunesSearch.d.ts.map

package/dist/itunes-search/iTunesSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iTunesSearch.d.ts","sourceRoot":"","sources":["../../src/itunes-search/iTunesSearch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAEhF,qBAAa,YAAY;;IAGvB,MAAM,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC;CAG1D"}

package/dist/itunes-search/iTunesSearch.js

@@ -0,0 +1,7 @@
+export class iTunesSearch {
+    constructor() { }
+    search(option) {
+        console.log('Searching iTunes for', option);
+    }
+}
+//# sourceMappingURL=iTunesSearch.js.map

package/dist/itunes-search/iTunesSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iTunesSearch.js","sourceRoot":"","sources":["../../src/itunes-search/iTunesSearch.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,YAAY;IACvB,gBAAe,CAAC;IAEhB,MAAM,CAAsB,MAA6B;QACvD,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC;IAC9C,CAAC;CACF"}

package/dist/itunes-search/itunes-search-options.d.ts

@@ -0,0 +1,15 @@
+export type MediaType = 'movie' | 'podcast' | 'music' | 'musicVideo' | 'audiobook' | 'shortFilm' | 'tvShow' | 'software' | 'ebook' | 'all';
+export type Entity = 'movieArtist' | 'movie' | 'podcastAuthor' | 'podcast' | 'musicArtist' | 'musicTrack' | 'album' | 'musicVideo' | 'mix' | 'song' | 'audiobookAuthor' | 'audiobook' | 'shortFilmArtist' | 'shortFilm' | 'tvEpisode' | 'tvSeason' | 'software' | 'iPadSoftware' | 'macSoftware' | 'ebook' | 'allArtist' | 'allTrack';
+type EntityForMediaType<T extends MediaType> = T extends 'movie' ? 'movieArtist' | 'movie' : T extends 'podcast' ? 'podcastAuthor' | 'podcast' : T extends 'music' ? 'musicArtist' | 'musicTrack' | 'album' | 'musicVideo' | 'mix' | 'song' : T extends 'musicVideo' ? 'musicArtist' | 'musicVideo' : T extends 'audiobook' ? 'audiobookAuthor' | 'audiobook' : T extends 'shortFilm' ? 'shortFilmArtist' | 'shortFilm' : T extends 'tvShow' ? 'tvEpisode' | 'tvSeason' : T extends 'software' ? 'software' | 'iPadSoftware' | 'macSoftware' : T extends 'ebook' ? 'ebook' : T extends 'all' ? 'movie' | 'album' | 'allArtist' | 'podcast' | 'musicVideo' | 'mix' | 'audiobook' | 'tvSeason' | 'allTrack' : never;
+export interface ITunesSearchParams<T extends MediaType> {
+    media: T;
+    entity?: EntityForMediaType<T>;
+    term: string;
+    country?: string;
+    limit?: number;
+    lang?: string;
+    version?: number;
+    explicit?: 'Yes' | 'No';
+}
+export {};
+//# sourceMappingURL=itunes-search-options.d.ts.map

package/dist/itunes-search/itunes-search-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itunes-search-options.d.ts","sourceRoot":"","sources":["../../src/itunes-search/itunes-search-options.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB,OAAO,GACP,SAAS,GACT,OAAO,GACP,YAAY,GACZ,WAAW,GACX,WAAW,GACX,QAAQ,GACR,UAAU,GACV,OAAO,GACP,KAAK,CAAC;AAEV,MAAM,MAAM,MAAM,GACd,aAAa,GACb,OAAO,GACP,eAAe,GACf,SAAS,GACT,aAAa,GACb,YAAY,GACZ,OAAO,GACP,YAAY,GACZ,KAAK,GACL,MAAM,GACN,iBAAiB,GACjB,WAAW,GACX,iBAAiB,GACjB,WAAW,GACX,WAAW,GACX,UAAU,GACV,UAAU,GACV,cAAc,GACd,aAAa,GACb,OAAO,GACP,WAAW,GACX,UAAU,CAAC;AAEf,KAAK,kBAAkB,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,SAAS,OAAO,GAC5D,aAAa,GAAG,OAAO,GACvB,CAAC,SAAS,SAAS,GACjB,eAAe,GAAG,SAAS,GAC3B,CAAC,SAAS,OAAO,GACf,aAAa,GAAG,YAAY,GAAG,OAAO,GAAG,YAAY,GAAG,KAAK,GAAG,MAAM,GACtE,CAAC,SAAS,YAAY,GACpB,aAAa,GAAG,YAAY,GAC5B,CAAC,SAAS,WAAW,GACnB,iBAAiB,GAAG,WAAW,GAC/B,CAAC,SAAS,WAAW,GACnB,iBAAiB,GAAG,WAAW,GAC/B,CAAC,SAAS,QAAQ,GAChB,WAAW,GAAG,UAAU,GACxB,CAAC,SAAS,UAAU,GAClB,UAAU,GAAG,cAAc,GAAG,aAAa,GAC3C,CAAC,SAAS,OAAO,GACf,OAAO,GACP,CAAC,SAAS,KAAK,GAET,OAAO,GACP,OAAO,GACP,WAAW,GACX,SAAS,GACT,YAAY,GACZ,KAAK,GACL,WAAW,GACX,UAAU,GACV,UAAU,GACd,KAAK,CAAC;AAE5B,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,SAAS;IACrD,KAAK,EAAE,CAAC,CAAC;IACT,MAAM,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;CACzB"}

package/dist/itunes-search/itunes-search-options.js

@@ -0,0 +1 @@
+export {};

package/dist/itunes-search/itunes-search-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"itunes-search-options.js","sourceRoot":"","sources":["../../src/itunes-search/itunes-search-options.ts"],"names":[],"mappings":""}

package/dist/itunes-search/itunes-search-result.d.ts

@@ -0,0 +1,41 @@
+export type WrapperType = 'track' | 'collection' | 'artist';
+export type Explicitness = 'explicit' | 'cleaned' | 'notExplicit';
+export type Kind = 'book' | 'album' | 'coached-audio' | 'feature-movie' | 'interactive-booklet' | 'music-video' | 'pdf' | 'podcast' | 'podcast-episode' | 'software-package' | 'song' | 'tv-episode' | 'artist';
+export interface ITunesSearchResult {
+    wrapperType: WrapperType;
+    kind: Kind;
+    artistId?: number;
+    collectionId?: number;
+    trackId?: number;
+    artistName?: string;
+    collectionName?: string;
+    trackName?: string;
+    collectionCensoredName?: string;
+    trackCensoredName?: string;
+    artistViewUrl?: string;
+    collectionViewUrl?: string;
+    trackViewUrl?: string;
+    previewUrl?: string;
+    artworkUrl30?: string;
+    artworkUrl60?: string;
+    artworkUrl100?: string;
+    collectionPrice?: number;
+    trackPrice?: number;
+    collectionExplicitness?: Explicitness;
+    trackExplicitness?: Explicitness;
+    discCount?: number;
+    discNumber?: number;
+    trackCount?: number;
+    trackNumber?: number;
+    trackTimeMillis?: number;
+    country?: string;
+    currency?: string;
+    primaryGenreName?: string;
+    releaseDate?: string;
+    feedUrl?: string;
+}
+export interface ITunesSearchResponse {
+    resultCount: number;
+    results: ITunesSearchResult[];
+}
+//# sourceMappingURL=itunes-search-result.d.ts.map

package/dist/itunes-search/itunes-search-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itunes-search-result.d.ts","sourceRoot":"","sources":["../../src/itunes-search/itunes-search-result.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,YAAY,GAAG,QAAQ,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,aAAa,CAAC;AAElE,MAAM,MAAM,IAAI,GACZ,MAAM,GACN,OAAO,GACP,eAAe,GACf,eAAe,GACf,qBAAqB,GACrB,aAAa,GACb,KAAK,GACL,SAAS,GACT,iBAAiB,GACjB,kBAAkB,GAClB,MAAM,GACN,YAAY,GACZ,QAAQ,CAAC;AAEb,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,IAAI,EAAE,IAAI,CAAC;IAEX,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,sBAAsB,CAAC,EAAE,YAAY,CAAC;IACtC,iBAAiB,CAAC,EAAE,YAAY,CAAC;IAEjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,kBAAkB,EAAE,CAAC;CAC/B"}

package/dist/itunes-search/itunes-search-result.js

@@ -0,0 +1 @@
+export {};

package/dist/itunes-search/itunes-search.d.ts

@@ -0,0 +1,9 @@
+import type { ITunesSearchParams, MediaType } from './itunes-search-options.js';
+import type { ITunesSearchResponse } from './itunes-search-result.js';
+export declare class ItunesSearch {
+    private static readonly ITUNES_SEARCH_URL;
+    constructor();
+    search<T extends MediaType>(option: ITunesSearchParams<T>): Promise<ITunesSearchResponse>;
+    private buildSearchUrl;
+}
+//# sourceMappingURL=itunes-search.d.ts.map

package/dist/itunes-search/itunes-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itunes-search.d.ts","sourceRoot":"","sources":["../../src/itunes-search/itunes-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAqC;;IAIxE,MAAM,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAuB/F,OAAO,CAAC,cAAc;CAWvB"}

package/dist/itunes-search/itunes-search.js

@@ -0,0 +1,30 @@
+export class ItunesSearch {
+    constructor() { }
+    async search(option) {
+        const searchUrlWithParams = this.buildSearchUrl(option);
+        try {
+            const response = await fetch(searchUrlWithParams);
+            if (!response.ok) {
+                // noinspection ExceptionCaughtLocallyJS
+                throw new Error(`Failed to fetch data from iTunes Search API: ${response.status}}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Fetch failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    buildSearchUrl(option) {
+        const url = new URL(ItunesSearch.ITUNES_SEARCH_URL);
+        for (const [key, value] of Object.entries(option)) {
+            if (value !== undefined) {
+                url.searchParams.append(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+}
+ItunesSearch.ITUNES_SEARCH_URL = 'https://itunes.apple.com/search';

package/dist/itunes-search/itunes-search.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=itunes-search.spec.d.ts.map

package/dist/itunes-search/itunes-search.spec.d.ts.map

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

package/dist/itunes-search/itunes-search.spec.js

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ItunesSearch } from './itunes-search';
+describe('itunesSearch', () => {
+    let searcher;
+    beforeEach(() => {
+        searcher = new ItunesSearch();
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    it('should return data with success when the response is ok', async () => {
+        const mockData = {
+            resultCount: 1,
+            results: [
+                {
+                    wrapperType: 'track',
+                    kind: 'song',
+                    trackName: 'Test Song',
+                    artistName: 'Test Artist',
+                    collectionName: 'Test Album',
+                    trackPrice: 0.99,
+                    country: 'USA',
+                    currency: 'USD',
+                    releaseDate: '2023-01-01T08:00:00Z',
+                    primaryGenreName: 'Pop',
+                },
+            ],
+        };
+        vi.mocked(fetch).mockResolvedValueOnce({
+            ok: true,
+            json: async () => mockData,
+        });
+        const result = await searcher.search({ term: 'test', media: 'music' });
+        expect(result).toEqual(mockData);
+        expect(fetch).toHaveBeenCalledWith(expect.stringContaining('https://itunes.apple.com/search?term=test&media=music'));
+    });
+    it("should raise an error if the http response is not ok (ex: 404)", async () => {
+        vi.mocked(fetch).mockResolvedValueOnce({
+            ok: false,
+            status: 404,
+        });
+        await expect(searcher.search({ term: 'invalid', media: 'podcast' })).rejects.toThrow('Failed to fetch data from iTunes Search API: 404');
+    });
+    it('should raise an error "Fetch failed" in case of network failure', async () => {
+        vi.mocked(fetch).mockRejectedValueOnce(new Error('Network Error'));
+        await expect(searcher.search({ term: 'test', media: 'podcast' })).rejects.toThrow('Fetch failed: Network Error');
+    });
+});

package/dist/podcast/podcast.d.ts

@@ -0,0 +1,55 @@
+export declare class PodcastLoader {
+    private readonly FETCH_TIMEOUT_MS;
+    /**
+     * Fetches and parses a podcast feed from the given URL
+     * @param feedUrl - The URL of the podcast feed
+     * @returns A Promise resolving to the parsed Podcast
+     * @throws Error if the feed is invalid or the fetch fails
+     */
+    getPodcastFromFeed(feedUrl: string): Promise<Podcast>;
+    private validateUrl;
+    private extractChannel;
+    private validateChannel;
+    private mapChannel;
+    private mapCategories;
+    private mapEpisodes;
+    private mapEnclosure;
+}
+export interface Category {
+    name: string;
+}
+export interface Episode {
+    title: string | undefined;
+    enclosure: Enclosure | undefined;
+    guid: string;
+    linkUrl?: string;
+    pubDate?: string;
+    description?: string;
+    durationInSeconds?: string | number | undefined;
+    imageUrl?: string;
+    explicit?: boolean;
+    number?: number;
+    season?: number;
+    type?: string | undefined;
+}
+export interface Enclosure {
+    length: string;
+    type: string;
+    url: string;
+}
+export interface Podcast {
+    title: string;
+    description: string | undefined;
+    link: string;
+    language: string | undefined;
+    categories: Category[];
+    explicit: boolean;
+    imageUrl?: string;
+    author?: string;
+    copyright?: string;
+    fundingUrl?: string;
+    type?: string;
+    complete?: boolean;
+    episodes?: Episode[];
+}
+//# sourceMappingURL=podcast.d.ts.map

package/dist/podcast/podcast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"podcast.d.ts","sourceRoot":"","sources":["../../src/podcast/podcast.ts"],"names":[],"mappings":"AAiDA,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAE1C;;;;;OAKG;IACG,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA0C3D,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,UAAU;IAiBlB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,WAAW;IAmBnB,OAAO,CAAC,YAAY;CASrB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,UAAU,EAAE,QAAQ,EAAE,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB"}

package/dist/podcast/podcast.js

@@ -0,0 +1,120 @@
+import { parseFeedToJson } from '@sesamy/podcast-parser';
+export class PodcastLoader {
+    constructor() {
+        this.FETCH_TIMEOUT_MS = 30000;
+    }
+    /**
+     * Fetches and parses a podcast feed from the given URL
+     * @param feedUrl - The URL of the podcast feed
+     * @returns A Promise resolving to the parsed Podcast
+     * @throws Error if the feed is invalid or the fetch fails
+     */
+    async getPodcastFromFeed(feedUrl) {
+        this.validateUrl(feedUrl);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.FETCH_TIMEOUT_MS);
+        try {
+            const response = await fetch(feedUrl, { signal: controller.signal });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch podcast feed: ${response.status} ${response.statusText}`);
+            }
+            const xmlString = await response.text();
+            if (!xmlString.trim()) {
+                throw new Error('Podcast feed is empty');
+            }
+            const podcastFromXml = await parseFeedToJson(xmlString);
+            const channel = this.extractChannel(podcastFromXml);
+            this.validateChannel(channel);
+            return this.mapChannel(channel);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Podcast feed request timeout after ${this.FETCH_TIMEOUT_MS}ms`);
+            }
+            if (error instanceof Error) {
+                throw new Error(`Failed to load podcast feed: ${error.message}`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    validateUrl(feedUrl) {
+        try {
+            new URL(feedUrl);
+        }
+        catch {
+            throw new Error(`Invalid feed URL: ${feedUrl}`);
+        }
+    }
+    extractChannel(podcastFromXml) {
+        const channel = podcastFromXml?.rss?.channel;
+        if (!channel) {
+            throw new Error('Invalid podcast feed: missing channel data');
+        }
+        return channel;
+    }
+    validateChannel(channel) {
+        if (!channel.title) {
+            throw new Error('Invalid podcast feed: missing required field "title"');
+        }
+        if (!channel.link) {
+            throw new Error('Invalid podcast feed: missing required field "link"');
+        }
+    }
+    mapChannel(channel) {
+        return {
+            title: channel.title,
+            description: channel.description,
+            link: channel.link,
+            language: channel.language,
+            categories: this.mapCategories(channel['itunes:category']),
+            explicit: channel['itunes:explicit'] === 'true',
+            imageUrl: channel['itunes:image']?.['@_href'],
+            author: channel['itunes:author'],
+            copyright: channel['copyright'],
+            fundingUrl: channel['podcast:funding']?.['@_url'],
+            type: channel['itunes:type'],
+            episodes: this.mapEpisodes(channel.item),
+        };
+    }
+    mapCategories(categories) {
+        if (!categories) {
+            return [];
+        }
+        return categories.flatMap((category) => [
+            { name: category['@_text'] },
+            ...(category['itunes:category']?.map((sub) => ({ name: sub['@_text'] })) || []),
+        ]);
+    }
+    mapEpisodes(items) {
+        if (!items) {
+            return [];
+        }
+        return items.map((item) => ({
+            title: item.title,
+            enclosure: this.mapEnclosure(item.enclosure),
+            guid: item.guid['#text'],
+            linkUrl: item.link,
+            pubDate: item.pubDate,
+            description: item.description,
+            durationInSeconds: item['itunes:duration'],
+            imageUrl: item['itunes:image']?.['@_href'],
+            explicit: item['itunes:explicit'] === 'yes',
+            number: item['itunes:episode'],
+            season: item['itunes:season'],
+            type: item['itunes:episodeType'],
+        }));
+    }
+    mapEnclosure(enclosure) {
+        if (!enclosure?.[0]) {
+            return undefined;
+        }
+        return {
+            url: enclosure[0]['@_url'],
+            type: enclosure[0]['@_type'],
+            length: enclosure[0]['@_length'],
+        };
+    }
+}

package/dist/podcast/podcast.spec.d.ts

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

package/dist/podcast/podcast.spec.d.ts.map

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

package/dist/podcast/podcast.spec.js

@@ -0,0 +1,364 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { PodcastLoader } from './podcast';
+vi.mock('@sesamy/podcast-parser', () => ({
+    parseFeedToJson: vi.fn(),
+}));
+import { parseFeedToJson } from '@sesamy/podcast-parser';
+describe('PodcastLoader', () => {
+    let podcastLoader;
+    beforeEach(() => {
+        podcastLoader = new PodcastLoader();
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getPodcastFromFeed', () => {
+        it('should successfully parse a valid podcast feed', async () => {
+            const mockXmlResponse = `<?xml version="1.0" encoding="UTF-8"?>
+        <rss version="2.0" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:podcast="https://podcastindex.org/namespace/1.0">
+          <channel>
+            <title>Test Podcast</title>
+            <description>A test podcast</description>
+            <link>https://example.com</link>
+            <language>en</language>
+            <itunes:category text="Technology">
+              <itunes:category text="Software How-To"/>
+            </itunes:category>
+            <itunes:explicit>false</itunes:explicit>
+            <itunes:image href="https://example.com/image.jpg"/>
+            <itunes:author>John Doe</itunes:author>
+            <copyright>2024 Test Podcast</copyright>
+            <podcast:funding url="https://example.com/support">Support Us</podcast:funding>
+            <itunes:type>episodic</itunes:type>
+            <item>
+              <title>Episode 1</title>
+              <guid>#text</guid>
+              <link>https://example.com/episode1</link>
+              <pubDate>Mon, 01 Jan 2024 12:00:00 GMT</pubDate>
+              <description>First episode</description>
+              <itunes:duration>3600</itunes:duration>
+              <itunes:image href="https://example.com/ep1.jpg"/>
+              <itunes:explicit>no</itunes:explicit>
+              <itunes:episode>1</itunes:episode>
+              <itunes:season>1</itunes:season>
+              <itunes:episodeType>full</itunes:episodeType>
+              <enclosure url="https://example.com/ep1.mp3" type="audio/mpeg" length="123456"/>
+            </item>
+          </channel>
+        </rss>`;
+            const mockParsedData = {
+                rss: {
+                    channel: {
+                        title: 'Test Podcast',
+                        description: 'A test podcast',
+                        link: 'https://example.com',
+                        language: 'en',
+                        'itunes:category': [
+                            {
+                                '@_text': 'Technology',
+                                'itunes:category': [{ '@_text': 'Software How-To' }],
+                            },
+                        ],
+                        'itunes:explicit': 'false',
+                        'itunes:image': { '@_href': 'https://example.com/image.jpg' },
+                        'itunes:author': 'John Doe',
+                        copyright: '2024 Test Podcast',
+                        'podcast:funding': { '@_url': 'https://example.com/support' },
+                        'itunes:type': 'episodic',
+                        item: [
+                            {
+                                title: 'Episode 1',
+                                guid: { '#text': 'episode-1-guid' },
+                                link: 'https://example.com/episode1',
+                                pubDate: 'Mon, 01 Jan 2024 12:00:00 GMT',
+                                description: 'First episode',
+                                'itunes:duration': '3600',
+                                'itunes:image': { '@_href': 'https://example.com/ep1.jpg' },
+                                'itunes:explicit': 'no',
+                                'itunes:episode': 1,
+                                'itunes:season': 1,
+                                'itunes:episodeType': 'full',
+                                enclosure: [
+                                    {
+                                        '@_url': 'https://example.com/ep1.mp3',
+                                        '@_type': 'audio/mpeg',
+                                        '@_length': '123456',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            };
+            vi.mocked(fetch).mockResolvedValueOnce({
+                ok: true,
+                text: async () => mockXmlResponse,
+            });
+            vi.mocked(parseFeedToJson).mockResolvedValueOnce(mockParsedData);
+            const result = await podcastLoader.getPodcastFromFeed('https://example.com/feed.xml');
+            expect(result.title).toBe('Test Podcast');
+            expect(result.description).toBe('A test podcast');
+            expect(result.link).toBe('https://example.com');
+            expect(result.language).toBe('en');
+            expect(result.explicit).toBe(false);
+            expect(result.imageUrl).toBe('https://example.com/image.jpg');
+            expect(result.author).toBe('John Doe');
+            expect(result.copyright).toBe('2024 Test Podcast');
+            expect(result.fundingUrl).toBe('https://example.com/support');
+            expect(result.type).toBe('episodic');
+            expect(result.categories).toHaveLength(2);
+            expect(result.episodes).toHaveLength(1);
+        });
+        it('should handle explicit content correctly', async () => {
+            const mockParsedData = {
+                rss: {
+                    channel: {
+                        title: 'Explicit Podcast',
+                        description: 'Contains explicit content',
+                        link: 'https://example.com',
+                        language: 'en',
+                        'itunes:explicit': 'true',
+                        item: [],
+                    },
+                },
+            };
+            vi.mocked(fetch).mockResolvedValueOnce({
+                ok: true,
+                text: async () => '<xml></xml>',
+            });
+            vi.mocked(parseFeedToJson).mockResolvedValueOnce(mockParsedData);
+            const result = await podcastLoader.getPodcastFromFeed('https://example.com/feed.xml');
+            expect(result.explicit).toBe(true);
+        });
+        it('should handle missing optional fields gracefully', async () => {
+            const mockParsedData = {
+                rss: {
+                    channel: {
+                        title: 'Minimal Podcast',
+                        link: 'https://example.com',
+                        item: [],
+                    },
+                },
+            };
+            vi.mocked(fetch).mockResolvedValueOnce({
+                ok: true,
+                text: async () => '<xml></xml>',
+            });
+            vi.mocked(parseFeedToJson).mockResolvedValueOnce(mockParsedData);
+            const result = await podcastLoader.getPodcastFromFeed('https://example.com/feed.xml');
+            expect(result.title).toBe('Minimal Podcast');
+            expect(result.description).toBeUndefined();
+            expect(result.imageUrl).toBeUndefined();
+            expect(result.author).toBeUndefined();
+            expect(result.copyright).toBeUndefined();
+            expect(result.fundingUrl).toBeUndefined();
+            expect(result.type).toBeUndefined();
+            expect(result.categories).toEqual([]);
+            expect(result.episodes).toEqual([]);
+        });
+        it('should throw an error when fetch fails', async () => {
+            vi.mocked(fetch).mockRejectedValueOnce(new Error('Network error'));
+            await expect(podcastLoader.getPodcastFromFeed('https://invalid.com/feed.xml')).rejects.toThrow('Network error');
+        });
+        it('should throw an error when response is not ok', async () => {
+            vi.mocked(fetch).mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+            });
+            await expect(podcastLoader.getPodcastFromFeed('https://example.com/feed.xml')).rejects.toThrow();
+        });
+    });
+    describe('mapCategories', () => {
+        it('should map single category without subcategories', () => {
+            const categories = [{ '@_text': 'Technology' }];
+            const result = podcastLoader['mapCategories'](categories);
+            expect(result).toEqual([{ name: 'Technology' }]);
+        });
+        it('should map categories with subcategories', () => {
+            const categories = [
+                {
+                    '@_text': 'Technology',
+                    'itunes:category': [
+                        { '@_text': 'Software How-To' },
+                        { '@_text': 'Gadgets' },
+                    ],
+                },
+            ];
+            const result = podcastLoader['mapCategories'](categories);
+            expect(result).toEqual([
+                { name: 'Technology' },
+                { name: 'Software How-To' },
+                { name: 'Gadgets' },
+            ]);
+        });
+        it('should handle multiple parent categories with subcategories', () => {
+            const categories = [
+                {
+                    '@_text': 'Technology',
+                    'itunes:category': [{ '@_text': 'Software How-To' }],
+                },
+                {
+                    '@_text': 'Business',
+                    'itunes:category': [{ '@_text': 'Careers' }],
+                },
+            ];
+            const result = podcastLoader['mapCategories'](categories);
+            expect(result).toEqual([
+                { name: 'Technology' },
+                { name: 'Software How-To' },
+                { name: 'Business' },
+                { name: 'Careers' },
+            ]);
+        });
+        it('should return empty array when categories is undefined', () => {
+            const result = podcastLoader['mapCategories'](undefined);
+            expect(result).toEqual([]);
+        });
+        it('should handle categories without subcategories', () => {
+            const categories = [
+                { '@_text': 'Technology' },
+                { '@_text': 'Business' },
+            ];
+            const result = podcastLoader['mapCategories'](categories);
+            expect(result).toEqual([
+                { name: 'Technology' },
+                { name: 'Business' },
+            ]);
+        });
+    });
+    describe('mapEpisodes', () => {
+        it('should map episodes with all fields', () => {
+            const items = [
+                {
+                    title: 'Episode 1',
+                    guid: { '#text': 'ep1-guid' },
+                    link: 'https://example.com/ep1',
+                    pubDate: 'Mon, 01 Jan 2024 12:00:00 GMT',
+                    description: 'First episode',
+                    'itunes:duration': '3600',
+                    'itunes:image': { '@_href': 'https://example.com/ep1.jpg' },
+                    'itunes:explicit': 'yes',
+                    'itunes:episode': 1,
+                    'itunes:season': 1,
+                    'itunes:episodeType': 'full',
+                    enclosure: [
+                        {
+                            '@_url': 'https://example.com/ep1.mp3',
+                            '@_type': 'audio/mpeg',
+                            '@_length': '123456',
+                        },
+                    ],
+                },
+            ];
+            const result = podcastLoader['mapEpisodes'](items);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({
+                title: 'Episode 1',
+                guid: 'ep1-guid',
+                linkUrl: 'https://example.com/ep1',
+                pubDate: 'Mon, 01 Jan 2024 12:00:00 GMT',
+                description: 'First episode',
+                durationInSeconds: '3600',
+                imageUrl: 'https://example.com/ep1.jpg',
+                explicit: true,
+                number: 1,
+                season: 1,
+                type: 'full',
+                enclosure: {
+                    url: 'https://example.com/ep1.mp3',
+                    type: 'audio/mpeg',
+                    length: '123456',
+                },
+            });
+        });
+        it('should handle episodes with minimal fields', () => {
+            const items = [
+                {
+                    title: 'Episode 1',
+                    guid: { '#text': 'ep1-guid' },
+                },
+            ];
+            const result = podcastLoader['mapEpisodes'](items);
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({
+                title: 'Episode 1',
+                guid: 'ep1-guid',
+                enclosure: undefined,
+                linkUrl: undefined,
+                pubDate: undefined,
+                description: undefined,
+                durationInSeconds: undefined,
+                imageUrl: undefined,
+                explicit: false,
+                number: undefined,
+                season: undefined,
+                type: undefined,
+            });
+        });
+        it('should handle explicit field as "no"', () => {
+            const items = [
+                {
+                    title: 'Clean Episode',
+                    guid: { '#text': 'ep-guid' },
+                    'itunes:explicit': 'no',
+                },
+            ];
+            const result = podcastLoader['mapEpisodes'](items);
+            expect(result[0].explicit).toBe(false);
+        });
+        it('should handle multiple episodes', () => {
+            const items = [
+                {
+                    title: 'Episode 1',
+                    guid: { '#text': 'ep1-guid' },
+                },
+                {
+                    title: 'Episode 2',
+                    guid: { '#text': 'ep2-guid' },
+                },
+            ];
+            const result = podcastLoader['mapEpisodes'](items);
+            expect(result).toHaveLength(2);
+            expect(result[0].title).toBe('Episode 1');
+            expect(result[1].title).toBe('Episode 2');
+        });
+    });
+    describe('mapEnclosure', () => {
+        it('should map enclosure with all fields', () => {
+            const enclosure = [
+                {
+                    '@_url': 'https://example.com/ep1.mp3',
+                    '@_type': 'audio/mpeg',
+                    '@_length': '123456',
+                },
+            ];
+            const result = podcastLoader['mapEnclosure'](enclosure);
+            expect(result).toEqual({
+                url: 'https://example.com/ep1.mp3',
+                type: 'audio/mpeg',
+                length: '123456',
+            });
+        });
+        it('should return undefined when enclosure is undefined', () => {
+            const result = podcastLoader['mapEnclosure'](undefined);
+            expect(result).toBeUndefined();
+        });
+        it('should return undefined when enclosure array is empty', () => {
+            const result = podcastLoader['mapEnclosure']([]);
+            expect(result).toBeUndefined();
+        });
+        it('should handle enclosure with different media types', () => {
+            const enclosures = [
+                {
+                    '@_url': 'https://example.com/ep1.m4a',
+                    '@_type': 'audio/mp4',
+                    '@_length': '654321',
+                },
+            ];
+            const result = podcastLoader['mapEnclosure'](enclosures);
+            expect(result?.type).toBe('audio/mp4');
+            expect(result?.url).toBe('https://example.com/ep1.m4a');
+        });
+    });
+});

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@rapthi/podca-ts",
+  "version": "1.0.0",
+  "description": "A TypeScript library for parsing and managing podcast feeds from RSS/iTunes feeds",
+  "author": "Thierry Rapillard <rapthi@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rapthi/podca-ts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rapthi/podca-ts/issues"
+  },
+  "homepage": "https://github.com/rapthi/podca-ts",
+  "keywords": [
+    "podcast",
+    "typescript",
+    "parser",
+    "itunes",
+    "rss",
+    "feed",
+    "xml"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write 'src/**/*.{ts,json}'",
+    "format:check": "prettier --check 'src/**/*.{ts,json}'",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm run test && npm run lint",
+    "ci": "npm run type-check && npm run format:check && npm run lint && npm run test:coverage && npm run build"
+  },
+  "dependencies": {
+    "@sesamy/podcast-parser": "^1.11.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^8.51.0",
+    "@vitest/coverage-v8": "^4.0.16",
+    "eslint": "^9.39.2",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0",
+    "vitest": "^4.0.16"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}