Feat/improvements

src/API/API.ts

@@ -8,11 +8,15 @@ import {
 	duration,
 	isPaused,
 	plugin,
+	volume as volumeStore,
 } from "src/store";
 import { get } from "svelte/store";
 import encodePodnotesURI from "src/utility/encodePodnotesURI";
 import { isLocalFile } from "src/utility/isLocalFile";
 
+const clampVolume = (value: number): number =>
+	Math.min(1, Math.max(0, value));
+
 export class API implements IAPI {
 	public get podcast(): Episode {
 		return get(currentEpisode);
@@ -34,6 +38,14 @@ export class API implements IAPI {
 		return !get(isPaused);
 	}
 
+	public get volume(): number {
+		return get(volumeStore);
+	}
+
+	public set volume(value: number) {
+		volumeStore.set(clampVolume(value));
+	}
+
 	/**
 	 * Gets the current time in the given moment format.
 	 * @param format Moment format.

src/API/IAPI.ts

@@ -5,6 +5,7 @@ export interface IAPI {
 	readonly isPlaying: boolean;
 	readonly length: number;
 	currentTime: number;
+	volume: number;
 
 	getPodcastTimeFormatted(
 		format: string,

src/constants.ts

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

src/main.ts

@@ -7,6 +7,8 @@ import {
 	playlists,
 	queue,
 	savedFeeds,
+	hidePlayedEpisodes,
+	volume,
 } from "src/store";
 import { Plugin, type WorkspaceLeaf } from "obsidian";
 import { API } from "src/API/API";
@@ -28,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";
@@ -40,6 +43,7 @@ import getContextMenuHandler from "./getContextMenuHandler";
 import getUniversalPodcastLink from "./getUniversalPodcastLink";
 import type { IconType } from "./types/IconType";
 import { TranscriptionService } from "./services/TranscriptionService";
+import type { Unsubscriber } from "svelte/store";
 
 export default class PodNotes extends Plugin implements IPodNotes {
 	public api!: IAPI;
@@ -64,10 +68,16 @@ export default class PodNotes extends Plugin implements IPodNotes {
 	private downloadedEpisodesController?: StoreController<{
 		[podcastName: string]: DownloadedEpisode[];
 	}>;
+	private hidePlayedEpisodesController?: StoreController<boolean>;
 	private transcriptionService?: TranscriptionService;
+	private volumeUnsubscribe?: Unsubscriber;
 
 	private maxLayoutReadyAttempts = 10;
 	private layoutReadyAttempts = 0;
+	private isReady = false;
+	private pendingSave: IPodNotesSettings | null = null;
+	private saveScheduled = false;
+	private saveChain: Promise<void> = Promise.resolve();
 
 	override async onload() {
 		plugin.set(this);
@@ -84,6 +94,10 @@ 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)),
+		);
 
 		this.playedEpisodeController = new EpisodeStatusController(
 			playedEpisodes,
@@ -102,8 +116,27 @@ 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) => {
+			const clamped = Math.min(1, Math.max(0, value));
+
+			if (clamped !== value) {
+				volume.set(clamped);
+				return;
+			}
+
+			if (clamped === this.settings.defaultVolume) {
+				return;
+			}
+
+			this.settings.defaultVolume = clamped;
+			void this.saveSettings();
+		});
 
 		this.addCommand({
 			id: "podnotes-show-leaf",
@@ -291,6 +324,8 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		);
 
 		this.registerEvent(getContextMenuHandler(this.app));
+
+		this.isReady = true;
 	}
 
 	onLayoutReady(): void {
@@ -337,6 +372,8 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		this.localFilesController?.off();
 		this.downloadedEpisodesController?.off();
 		this.currentEpisodeController?.off();
+		this.hidePlayedEpisodesController?.off();
+		this.volumeUnsubscribe?.();
 	}
 
 	async loadSettings() {
@@ -350,6 +387,45 @@ export default class PodNotes extends Plugin implements IPodNotes {
 	}
 
 	async saveSettings() {
-		await this.saveData(this.settings);
+		if (!this.isReady) return;
+
+		this.pendingSave = this.cloneSettings();
+
+		if (this.saveScheduled) {
+			return this.saveChain;
+		}
+
+		this.saveScheduled = true;
+
+		this.saveChain = this.saveChain
+			.then(async () => {
+				while (this.pendingSave) {
+					const snapshot = this.pendingSave;
+					this.pendingSave = null;
+					await this.saveData(snapshot);
+				}
+			})
+			.catch((error) => {
+				console.error("PodNotes: failed to save settings", error);
+			})
+			.finally(() => {
+				this.saveScheduled = false;
+
+				// If a save was requested while we were saving, run again.
+				if (this.pendingSave) {
+					void this.saveSettings();
+				}
+			});
+
+		return this.saveChain;
+	}
+
+	private cloneSettings(): IPodNotesSettings {
+		// structuredClone is available in Obsidian's Electron runtime; fallback for safety.
+		if (typeof structuredClone === "function") {
+			return structuredClone(this.settings);
+		}
+
+		return JSON.parse(JSON.stringify(this.settings)) as IPodNotesSettings;
 	}
 }

src/services/TranscriptionService.ts

@@ -56,18 +56,15 @@ export class TranscriptionService {
 	private readonly CHUNK_SIZE_BYTES = 20 * 1024 * 1024;
 	private readonly WAV_HEADER_SIZE = 44;
 	private readonly PCM_BYTES_PER_SAMPLE = 2;
-	private isTranscribing = false;
+	private readonly MAX_CONCURRENT_TRANSCRIPTIONS = 2;
+	private pendingEpisodes: Episode[] = [];
+	private activeTranscriptions = new Set<string>();
 
 	constructor(plugin: PodNotes) {
 		this.plugin = plugin;
 	}
 
 	async transcribeCurrentEpisode(): Promise<void> {
-		if (this.isTranscribing) {
-			new Notice("A transcription is already in progress.");
-			return;
-		}
-
 		if (!this.plugin.settings.openAIApiKey?.trim()) {
 			new Notice(
 				"Please add your OpenAI API key in the transcript settings first.",
@@ -81,7 +78,6 @@ export class TranscriptionService {
 			return;
 		}
 
-		// Check if transcription file already exists
 		const transcriptPath = FilePathTemplateEngine(
 			this.plugin.settings.transcript.path,
 			currentEpisode,
@@ -95,13 +91,72 @@ export class TranscriptionService {
 			return;
 		}
 
-		this.isTranscribing = true;
-		const notice = TimerNotice("Transcription", "Preparing to transcribe...");
+		const episodeKey = this.getEpisodeKey(currentEpisode);
+		const isAlreadyQueued =
+			this.pendingEpisodes.some(
+				(episode) => this.getEpisodeKey(episode) === episodeKey,
+			) || this.activeTranscriptions.has(episodeKey);
+
+		if (isAlreadyQueued) {
+			new Notice("This episode is already queued or transcribing.");
+			return;
+		}
+
+		this.pendingEpisodes.push(currentEpisode);
+		new Notice(
+			`Queued "${currentEpisode.title}" for transcription. It will start automatically.`,
+		);
+		this.drainQueue();
+	}
+
+	private drainQueue(): void {
+		while (
+			this.activeTranscriptions.size < this.MAX_CONCURRENT_TRANSCRIPTIONS &&
+			this.pendingEpisodes.length > 0
+		) {
+			const nextEpisode = this.pendingEpisodes.shift();
+			if (!nextEpisode) {
+				return;
+			}
+
+			const episodeKey = this.getEpisodeKey(nextEpisode);
+			this.activeTranscriptions.add(episodeKey);
+
+			void this.transcribeEpisode(nextEpisode).finally(() => {
+				this.activeTranscriptions.delete(episodeKey);
+				this.drainQueue();
+			});
+		}
+	}
+
+	private getEpisodeKey(episode: Episode): string {
+		return `${episode.podcastName}:${episode.title}`;
+	}
+
+	private async transcribeEpisode(episode: Episode): Promise<void> {
+		const notice = TimerNotice(
+			`Transcription: ${episode.title}`,
+			"Preparing to transcribe...",
+		);
 
 		try {
+			const transcriptPath = FilePathTemplateEngine(
+				this.plugin.settings.transcript.path,
+				episode,
+			);
+			const existingFile =
+				this.plugin.app.vault.getAbstractFileByPath(transcriptPath);
+			if (existingFile instanceof TFile) {
+				notice.stop();
+				notice.update(
+					`Transcript already exists - skipped (${transcriptPath}).`,
+				);
+				return;
+			}
+
 			notice.update("Downloading episode...");
 			const downloadPath = await downloadEpisode(
-				currentEpisode,
+				episode,
 				this.plugin.settings.download.path,
 			);
 			const podcastFile =
@@ -127,16 +182,17 @@ export class TranscriptionService {
 			const transcription = await this.transcribeChunks(files, notice.update);
 
 			notice.update("Saving transcription...");
-			await this.saveTranscription(currentEpisode, transcription);
+			await this.saveTranscription(episode, transcription);
 
 			notice.stop();
 			notice.update("Transcription completed and saved.");
 		} catch (error) {
 			console.error("Transcription error:", error);
 			const message = error instanceof Error ? error.message : String(error);
+			notice.stop();
 			notice.update(`Transcription failed: ${message}`);
 		} finally {
-			this.isTranscribing = false;
+			notice.stop();
 			setTimeout(() => notice.hide(), 5000);
 		}
 	}