Merge master into cache-first-feed-loading

Author: chhoumann

src/constants.ts

@@ -34,6 +34,7 @@ export const DEFAULT_SETTINGS: IPodNotesSettings = {
 	podNotes: {},
 	defaultPlaybackRate: 1,
 	defaultVolume: 1,
+	hidePlayedEpisodes: false,
 	playedEpisodes: {},
 	favorites: {
 		...FAVORITES_SETTINGS,

src/main.ts

@@ -7,6 +7,7 @@ import {
 	playlists,
 	queue,
 	savedFeeds,
+	hidePlayedEpisodes,
 	volume,
 } from "src/store";
 import { Plugin, type WorkspaceLeaf } from "obsidian";
@@ -29,6 +30,7 @@ import { QueueController } from "./store_controllers/QueueController";
 import { FavoritesController } from "./store_controllers/FavoritesController";
 import type { Episode } from "./types/Episode";
 import CurrentEpisodeController from "./store_controllers/CurrentEpisodeController";
+import { HidePlayedEpisodesController } from "./store_controllers/HidePlayedEpisodesController";
 import { TimestampTemplateEngine } from "./TemplateEngine";
 import createPodcastNote from "./createPodcastNote";
 import downloadEpisodeWithNotice from "./downloadEpisode";
@@ -66,6 +68,7 @@ export default class PodNotes extends Plugin implements IPodNotes {
 	private downloadedEpisodesController?: StoreController<{
 		[podcastName: string]: DownloadedEpisode[];
 	}>;
+	private hidePlayedEpisodesController?: StoreController<boolean>;
 	private transcriptionService?: TranscriptionService;
 	private volumeUnsubscribe?: Unsubscriber;
 
@@ -87,6 +90,7 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		if (this.settings.currentEpisode) {
 			currentEpisode.set(this.settings.currentEpisode);
 		}
+		hidePlayedEpisodes.set(this.settings.hidePlayedEpisodes);
 		volume.set(
 			Math.min(1, Math.max(0, this.settings.defaultVolume ?? 1)),
 		);
@@ -108,6 +112,10 @@ export default class PodNotes extends Plugin implements IPodNotes {
 			currentEpisode,
 			this,
 		).on();
+		this.hidePlayedEpisodesController = new HidePlayedEpisodesController(
+			hidePlayedEpisodes,
+			this,
+		).on();
 
 		this.api = new API();
 		this.volumeUnsubscribe = volume.subscribe((value) => {
@@ -358,6 +366,7 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		this.localFilesController?.off();
 		this.downloadedEpisodesController?.off();
 		this.currentEpisodeController?.off();
+		this.hidePlayedEpisodesController?.off();
 		this.volumeUnsubscribe?.();
 	}
 

src/store/index.ts

@@ -1,4 +1,4 @@
-import { get, writable } from "svelte/store";
+import { get, readable, writable } from "svelte/store";
 import type PodNotes from "src/main";
 import type { Episode } from "src/types/Episode";
 import type { PlayedEpisode } from "src/types/PlayedEpisode";
@@ -13,6 +13,7 @@ export const plugin = writable<PodNotes>();
 export const currentTime = writable<number>(0);
 export const duration = writable<number>(0);
 export const volume = writable<number>(1);
+export const hidePlayedEpisodes = writable<boolean>(false);
 
 export const currentEpisode = (() => {
 	const store = writable<Episode>();
@@ -102,6 +103,199 @@ export const savedFeeds = writable<{ [podcastName: string]: PodcastFeed }>({});
 
 export const episodeCache = writable<{ [podcastName: string]: Episode[] }>({});
 
+const LATEST_EPISODES_PER_FEED = 10;
+
+type LatestEpisodesByFeed = Map<string, Episode[]>;
+type FeedEpisodeSources = Map<string, Episode[]>;
+type LatestEpisodePointer = {
+	feedTitle: string;
+	index: number;
+	episode: Episode;
+};
+
+function getEpisodeTimestamp(episode?: Episode): number {
+	if (!episode?.episodeDate) return 0;
+
+	return Number(episode.episodeDate);
+}
+
+function getLatestEpisodesForFeed(episodes: Episode[]): Episode[] {
+	if (!episodes?.length) return [];
+
+	return episodes
+		.slice(0, LATEST_EPISODES_PER_FEED)
+		.sort((a, b) => getEpisodeTimestamp(b) - getEpisodeTimestamp(a));
+}
+
+function shallowEqualEpisodes(a?: Episode[], b?: Episode[]): boolean {
+	if (!a || !b || a.length !== b.length) return false;
+
+	for (let i = 0; i < a.length; i += 1) {
+		if (a[i] !== b[i]) return false;
+	}
+
+	return true;
+}
+
+function pushEpisodePointer(
+	heap: LatestEpisodePointer[],
+	pointer: LatestEpisodePointer,
+): void {
+	heap.push(pointer);
+	let idx = heap.length - 1;
+
+	while (idx > 0) {
+		const parent = Math.floor((idx - 1) / 2);
+		if (
+			getEpisodeTimestamp(heap[parent].episode) >=
+			getEpisodeTimestamp(heap[idx].episode)
+		) {
+			break;
+		}
+
+		heap[idx] = heap[parent];
+		heap[parent] = pointer;
+		idx = parent;
+	}
+}
+
+function popEpisodePointer(
+	heap: LatestEpisodePointer[],
+): LatestEpisodePointer | undefined {
+	if (heap.length === 0) return undefined;
+
+	const top = heap[0];
+	const last = heap.pop();
+
+	if (last && heap.length > 0) {
+		heap[0] = last;
+		let idx = 0;
+
+		while (true) {
+			const left = idx * 2 + 1;
+			const right = idx * 2 + 2;
+			let largest = idx;
+
+			if (
+				left < heap.length &&
+				getEpisodeTimestamp(heap[left].episode) >
+					getEpisodeTimestamp(heap[largest].episode)
+			) {
+				largest = left;
+			}
+
+			if (
+				right < heap.length &&
+				getEpisodeTimestamp(heap[right].episode) >
+					getEpisodeTimestamp(heap[largest].episode)
+			) {
+				largest = right;
+			}
+
+			if (largest === idx) break;
+
+			const temp = heap[idx];
+			heap[idx] = heap[largest];
+			heap[largest] = temp;
+			idx = largest;
+		}
+	}
+
+	return top;
+}
+
+// Use a max-heap to merge the latest episodes from each feed without
+// resorting the entire cache every time a single feed updates.
+function mergeLatestEpisodes(latestByFeed: LatestEpisodesByFeed): Episode[] {
+	const heap: LatestEpisodePointer[] = [];
+
+	for (const [feedTitle, episodes] of latestByFeed.entries()) {
+		if (!episodes.length) continue;
+
+		pushEpisodePointer(heap, {
+			feedTitle,
+			index: 0,
+			episode: episodes[0],
+		});
+	}
+
+	const merged: Episode[] = [];
+	while (heap.length > 0) {
+		const pointer = popEpisodePointer(heap);
+		if (!pointer) break;
+
+		merged.push(pointer.episode);
+
+		const feedEpisodes = latestByFeed.get(pointer.feedTitle);
+		const nextIndex = pointer.index + 1;
+		if (feedEpisodes && nextIndex < feedEpisodes.length) {
+			pushEpisodePointer(heap, {
+				feedTitle: pointer.feedTitle,
+				index: nextIndex,
+				episode: feedEpisodes[nextIndex],
+			});
+		}
+	}
+
+	return merged;
+}
+
+export const latestEpisodes = readable<Episode[]>([], (set) => {
+	let latestByFeed: LatestEpisodesByFeed = new Map();
+	let feedSources: FeedEpisodeSources = new Map();
+
+	const unsubscribe = episodeCache.subscribe((cache) => {
+		let changed = false;
+		const nextSources: FeedEpisodeSources = new Map();
+		const nextLatestByFeed: LatestEpisodesByFeed = new Map();
+
+		for (const [feedTitle, episodes] of Object.entries(cache)) {
+			nextSources.set(feedTitle, episodes);
+			const previousSource = feedSources.get(feedTitle);
+			const previousLatest = latestByFeed.get(feedTitle);
+
+			if (previousSource === episodes && previousLatest) {
+				nextLatestByFeed.set(feedTitle, previousLatest);
+				continue;
+			}
+
+			const latestForFeed = getLatestEpisodesForFeed(episodes);
+			nextLatestByFeed.set(feedTitle, latestForFeed);
+
+			if (!changed) {
+				changed =
+					!previousLatest ||
+					!shallowEqualEpisodes(previousLatest, latestForFeed);
+			}
+		}
+
+		if (!changed) {
+			for (const feedTitle of feedSources.keys()) {
+				if (!nextSources.has(feedTitle)) {
+					changed = true;
+					break;
+				}
+			}
+		}
+
+		feedSources = nextSources;
+
+		if (!changed && nextLatestByFeed.size === latestByFeed.size) {
+			latestByFeed = nextLatestByFeed;
+			return;
+		}
+
+		latestByFeed = nextLatestByFeed;
+		set(mergeLatestEpisodes(latestByFeed));
+	});
+
+	return () => {
+		latestByFeed.clear();
+		feedSources.clear();
+		unsubscribe();
+	};
+});
+
 export const downloadedEpisodes = (() => {
 	const store = writable<{ [podcastName: string]: DownloadedEpisode[] }>({});
 	const { subscribe, update, set } = store;

src/store_controllers/HidePlayedEpisodesController.ts

@@ -0,0 +1,19 @@
+import type { Writable } from "svelte/store";
+import type { IPodNotes } from "../types/IPodNotes";
+import { StoreController } from "../types/StoreController";
+
+export class HidePlayedEpisodesController extends StoreController<boolean> {
+	private plugin: IPodNotes;
+
+	constructor(store: Writable<boolean>, plugin: IPodNotes) {
+		super(store);
+		this.plugin = plugin;
+	}
+
+	protected override onChange(value: boolean) {
+		if (this.plugin.settings.hidePlayedEpisodes === value) return;
+
+		this.plugin.settings.hidePlayedEpisodes = value;
+		this.plugin.saveSettings();
+	}
+}

src/types/IPodNotesSettings.ts

@@ -10,6 +10,7 @@ export interface IPodNotesSettings {
 	podNotes: { [episodeName: string]: PodNote };
 	defaultPlaybackRate: number;
 	defaultVolume: number;
+	hidePlayedEpisodes: boolean;
 	playedEpisodes: { [episodeName: string]: PlayedEpisode };
 	skipBackwardLength: number;
 	skipForwardLength: number;

src/ui/PodcastView/EpisodeList.svelte

@@ -1,15 +1,14 @@
 <script lang="ts">
 	import type { Episode } from "src/types/Episode";
-	import { createEventDispatcher, onMount } from "svelte";
+	import { createEventDispatcher } from "svelte";
 	import EpisodeListItem from "./EpisodeListItem.svelte";
-	import { playedEpisodes } from "src/store";
+	import { hidePlayedEpisodes, playedEpisodes } from "src/store";
 	import Icon from "../obsidian/Icon.svelte";
 	import Text from "../obsidian/Text.svelte";
 
 	export let episodes: Episode[] = [];
 	export let showThumbnails: boolean = false;
 	export let showListMenu: boolean = true;
-	let hidePlayedEpisodes: boolean = false;
 	let searchInputQuery: string = "";
 
 	const dispatch = createEventDispatcher();
@@ -48,11 +47,11 @@
 				/>
 			</div>
 			<Icon
-				icon={hidePlayedEpisodes ? "eye-off" : "eye"}
+				icon={$hidePlayedEpisodes ? "eye-off" : "eye"}
 				size={25}
-				label={hidePlayedEpisodes ? "Show played episodes" : "Hide played episodes"}
-				pressed={hidePlayedEpisodes}
-				on:click={() => (hidePlayedEpisodes = !hidePlayedEpisodes)}
+				label={$hidePlayedEpisodes ? "Show played episodes" : "Hide played episodes"}
+				pressed={$hidePlayedEpisodes}
+				on:click={() => hidePlayedEpisodes.update((value) => !value)}
 			/>
 			<Icon
 				icon="refresh-cw"
@@ -67,9 +66,9 @@
 		{#if episodes.length === 0}
 			<p>No episodes found.</p>
 		{/if}
-		{#each episodes as episode}
+		{#each episodes as episode (episode.url || episode.streamUrl || `${episode.title}-${episode.episodeDate ?? ""}`)}
 			{@const episodePlayed = $playedEpisodes[episode.title]?.finished}
-			{#if !hidePlayedEpisodes || !episodePlayed}
+			{#if !$hidePlayedEpisodes || !episodePlayed}
 				<EpisodeListItem
 					{episode}
 					episodeFinished={episodePlayed}
@@ -86,17 +85,19 @@
 	.episode-list-view-container {
 		display: flex;
 		flex-direction: column;
-		align-items: center;
-		justify-content: center;
+		align-items: stretch;
+		justify-content: flex-start;
+		width: 100%;
 	}
 
 	.podcast-episode-list {
 		display: flex;
 		flex-direction: column;
-		align-items: center;
-		justify-content: center;
+		align-items: stretch;
+		justify-content: flex-start;
 		width: 100%;
 		height: 100%;
+		gap: 0.25rem;
 	}
 
 	.episode-list-menu {