fix(episodes): harden episodeListLimit per review (cache cap, sort order, import, load sanitize)

- Align MAX_EPISODE_LIST_LIMIT with the feed cache's per-feed retention (75) so a
  chosen limit is always serveable from a warm cache; selecting a podcast still
  shows its full archive.
- Sort each feed by date before truncating so the per-feed limit keeps the NEWEST
  episodes even when the feed/cache is not newest-first.
- Rehydrate the episodeListLimit store on settings import (was only persisted).
- Sanitize episodeListLimit in loadSettings so a malformed persisted value is
  repaired in the settings object, not just clamped at runtime.
- Settings input: don't clobber the saved limit on empty/mid-edit input and skip
  redundant saves.
- Rebuild the latest list with a single sort+slice on limit change.

Refs #114

Author: chhoumann

docs/docs/podcasts.md

@@ -38,10 +38,11 @@ podcast is selected, so episodes older than the limit will not appear in those
 search results.
 
 You can change this with the **Latest episodes per podcast** setting in the
-PodNotes settings tab. It defaults to 10. Raise it to surface more of each
-feed's history in the Latest Episodes list and to search further back; lower it
-for a shorter list. Selecting an individual podcast still shows all of that
-podcast's episodes regardless of this setting.
+PodNotes settings tab. It defaults to 10 and can be raised up to 75. Raise it to
+surface more of each feed's history in the Latest Episodes list and to search
+further back; lower it for a shorter list. Selecting an individual podcast still
+shows all of that podcast's episodes regardless of this setting, so the full
+back catalogue of any one show always remains searchable from its own view.
 
 ## Context menu
 You can right-click (desktop) or long-press (mobile) on an episode in the episode list to open the context menu.

src/constants.ts

@@ -12,11 +12,14 @@ export const VIEW_TYPE = "podcast_player_view";
 export const DEFAULT_EPISODE_LIST_LIMIT = 10;
 
 /**
- * Upper bound for {@link DEFAULT_EPISODE_LIST_LIMIT}. Keeps an accidental huge
- * value (e.g. a fat-fingered settings entry) from materialising an unbounded
- * latest-episodes list.
+ * Upper bound for {@link DEFAULT_EPISODE_LIST_LIMIT}. Kept in lockstep with the
+ * feed cache's `MAX_EPISODES_PER_FEED` (see src/services/FeedCacheService.ts):
+ * on a warm start the Latest Episodes list is rebuilt from the persisted cache,
+ * which retains at most that many episodes per feed, so a limit larger than the
+ * cap could never actually be served. Selecting an individual podcast still
+ * shows that feed's full episode list, unbounded by this setting.
  */
-export const MAX_EPISODE_LIST_LIMIT = 1000;
+export const MAX_EPISODE_LIST_LIMIT = 75;
 
 type PlaylistSettings = Pick<
 	Playlist,

src/main.ts

@@ -102,9 +102,9 @@ export default class PodNotes extends Plugin implements IPodNotes {
 			currentEpisode.set(this.settings.currentEpisode);
 		}
 		hidePlayedEpisodes.set(this.settings.hidePlayedEpisodes);
-		episodeListLimit.set(
-			sanitizeEpisodeListLimit(this.settings.episodeListLimit),
-		);
+		// loadSettings() already sanitized this, so the store stays in sync with
+		// the (repaired) persisted value.
+		episodeListLimit.set(this.settings.episodeListLimit);
 		volume.set(
 			Math.min(1, Math.max(0, this.settings.defaultVolume ?? 1)),
 		);
@@ -462,6 +462,12 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		this.settings.download.path = migrateDownloadPath(
 			this.settings.download.path,
 		);
+		// Normalise the persisted limit so a malformed value (e.g. 0 from an older
+		// data.json) is repaired in the settings object too, not just clamped for
+		// runtime behaviour, and so a later saveSettings() can't re-persist it (#114).
+		this.settings.episodeListLimit = sanitizeEpisodeListLimit(
+			this.settings.episodeListLimit,
+		);
 	}
 
 	async saveSettings() {

src/services/FeedCacheService.ts

@@ -22,6 +22,9 @@ const STORAGE_KEY = "podnotes:feed-cache:v2";
 // orphan ~MBs of data (which could push v2 writes over the localStorage quota).
 const LEGACY_STORAGE_KEYS = ["podnotes:feed-cache:v1"];
 const DEFAULT_TTL_MS = 1000 * 60 * 60 * 6; // 6 hours.
+// Keep this >= MAX_EPISODE_LIST_LIMIT (src/constants.ts): the Latest Episodes
+// list is rebuilt from this persisted cache on a warm start, so a per-feed list
+// limit larger than what we retain here could never be served (issue #114).
 const MAX_EPISODES_PER_FEED = 75;
 const MAX_CACHE_SIZE_BYTES = 4 * 1024 * 1024; // 4MB to leave room for other localStorage usage
 

src/store/index.test.ts

@@ -540,15 +540,27 @@ describe("sanitizeEpisodeListLimit (issue #114)", () => {
 	});
 
 	test("clamps to the maximum", () => {
+		expect(sanitizeEpisodeListLimit(MAX_EPISODE_LIST_LIMIT)).toBe(
+			MAX_EPISODE_LIST_LIMIT,
+		);
+		expect(sanitizeEpisodeListLimit(MAX_EPISODE_LIST_LIMIT + 1)).toBe(
+			MAX_EPISODE_LIST_LIMIT,
+		);
 		expect(sanitizeEpisodeListLimit(10 ** 9)).toBe(MAX_EPISODE_LIST_LIMIT);
 	});
 });
 
 describe("latestEpisodes respects episodeListLimit (issue #114)", () => {
-	// Newest-first like a real RSS feed; the store re-sorts by date anyway.
-	function feedEpisodes(podcastName: string, count: number): Episode[] {
-		return Array.from({ length: count }, (_, i) => {
-			const ordinal = count - i;
+	// `ordinal` doubles as the day-of-month, so a higher ordinal is a newer
+	// episode. `order: "newest-first"` mimics a typical RSS feed; "oldest-first"
+	// stresses that the per-feed limit ranks by date before truncating.
+	function feedEpisodes(
+		podcastName: string,
+		count: number,
+		order: "newest-first" | "oldest-first" = "newest-first",
+	): Episode[] {
+		const episodes = Array.from({ length: count }, (_, i) => {
+			const ordinal = i + 1;
 			return {
 				title: `${podcastName} #${ordinal}`,
 				streamUrl: `https://example.com/${podcastName}/${ordinal}.mp3`,
@@ -559,6 +571,7 @@ describe("latestEpisodes respects episodeListLimit (issue #114)", () => {
 				episodeDate: new Date(2020, 0, ordinal),
 			} satisfies Episode;
 		});
+		return order === "newest-first" ? episodes.reverse() : episodes;
 	}
 
 	function trackLatest(): { value: () => Episode[]; stop: () => void } {
@@ -636,6 +649,25 @@ describe("latestEpisodes respects episodeListLimit (issue #114)", () => {
 		expect(tracker.value()).toHaveLength(10);
 		tracker.stop();
 	});
+
+	test("selects the newest episodes even when the feed is oldest-first", () => {
+		const tracker = trackLatest();
+		episodeListLimit.set(3);
+
+		// Episodes 1..25 in ascending (oldest-first) order. A naive slice-before-sort
+		// would keep #1..#3 (the oldest); the limit must rank by date and keep the
+		// newest three.
+		episodeCache.set({
+			"Show A": feedEpisodes("Show A", 25, "oldest-first"),
+		});
+
+		expect(tracker.value().map((episode) => episode.title)).toEqual([
+			"Show A #25",
+			"Show A #24",
+			"Show A #23",
+		]);
+		tracker.stop();
+	});
 });
 
 describe("currentEpisode.set finished guard (issue #94)", () => {

src/store/index.ts

@@ -223,9 +223,13 @@ function getLatestEpisodesForFeed(
 ): Episode[] {
 	if (!episodes?.length) return [];
 
-	return episodes
-		.slice(0, perFeedLimit)
-		.sort((a, b) => getEpisodeTimestamp(b) - getEpisodeTimestamp(a));
+	// Sort by date first, THEN take the newest N. Slicing before sorting would
+	// only keep the newest episodes when the feed is already newest-first; for a
+	// feed (or cache) in any other order it would surface the wrong episodes, so
+	// the per-feed limit must rank the whole feed before truncating (issue #114).
+	return [...episodes]
+		.sort((a, b) => getEpisodeTimestamp(b) - getEpisodeTimestamp(a))
+		.slice(0, perFeedLimit);
 }
 
 function shallowEqualEpisodes(a?: Episode[], b?: Episode[]): boolean {
@@ -376,7 +380,7 @@ export const latestEpisodes = readable<Episode[]>([], (set) => {
 
 		const nextSources: FeedEpisodeSources = new Map();
 		const nextLatestByFeed: LatestEpisodesByFeed = new Map();
-		let nextMerged: Episode[] = [];
+		const collected: Episode[] = [];
 
 		for (const [feedTitle, episodes] of cacheEntries) {
 			const nextLatestForFeed = getLatestEpisodesForFeed(
@@ -385,12 +389,16 @@ export const latestEpisodes = readable<Episode[]>([], (set) => {
 			);
 			nextSources.set(feedTitle, episodes);
 			nextLatestByFeed.set(feedTitle, nextLatestForFeed);
-
-			for (const episode of nextLatestForFeed) {
-				nextMerged = insertEpisodeSorted(nextMerged, episode, latestLimit);
-			}
+			collected.push(...nextLatestForFeed);
 		}
 
+		// Merge once: sort the gathered per-feed slices by date and cap. A single
+		// sort avoids the repeated full-array copies insertEpisodeSorted would do
+		// per episode, keeping this user-triggered rebuild off the slow path.
+		const nextMerged = collected
+			.sort((a, b) => getEpisodeTimestamp(b) - getEpisodeTimestamp(a))
+			.slice(0, latestLimit);
+
 		feedSources = nextSources;
 		latestByFeed = nextLatestByFeed;
 

src/ui/settings/PodNotesSettingsTab.ts

@@ -151,7 +151,14 @@ export class PodNotesSettingsTab extends PluginSettingTab {
 					)
 					.setPlaceholder(`${DEFAULT_EPISODE_LIST_LIMIT}`)
 					.onChange(async (value) => {
-						const sanitized = sanitizeEpisodeListLimit(value);
+						// Don't commit while the field is empty or mid-edit (e.g. cleared,
+						// or a lone "-"): sanitizing "" would silently overwrite the saved
+						// limit with the default. Wait for a parseable number, and skip
+						// redundant saves so typing doesn't churn data.json each keystroke.
+						const trimmed = value.trim();
+						if (trimmed === "" || !Number.isFinite(Number(trimmed))) return;
+						const sanitized = sanitizeEpisodeListLimit(trimmed);
+						if (sanitized === this.plugin.settings.episodeListLimit) return;
 						this.plugin.settings.episodeListLimit = sanitized;
 						episodeListLimit.set(sanitized);
 						await this.plugin.saveSettings();
@@ -770,6 +777,9 @@ export class PodNotesSettingsTab extends PluginSettingTab {
 		queue.set(merged.queue);
 		localFiles.set(merged.localFiles);
 		hidePlayedEpisodes.set(merged.hidePlayedEpisodes);
+		const sanitizedLimit = sanitizeEpisodeListLimit(merged.episodeListLimit);
+		merged.episodeListLimit = sanitizedLimit;
+		episodeListLimit.set(sanitizedLimit);
 		const importedVolume = Number.isFinite(merged.defaultVolume)
 			? merged.defaultVolume
 			: 1;