Merge branch 'master' into vite-migration-setup

Resolve conflicts by:
- Keeping master's lazy initialization approach for TranscriptionService with getTranscriptionService()
- Using optional transcriptionService property (?) for safety
- Maintaining our branch's override keyword in onunload()
- Using our branch's optional chaining (?.) for safer controller cleanup
- Using our branch's getErrorMessage() helper for consistent error handling
- Accepting master's new performance settings and feed caching features
- Accepting master's accessibility improvements to UI components

All changes from master's PR #124 (feed caching and UI accessibility) are now integrated.

Author: chhoumann

src/constants.ts

@@ -70,4 +70,8 @@ export const DEFAULT_SETTINGS: IPodNotesSettings = {
 		template:
 			"# {{title}}\n\nPodcast: {{podcast}}\nDate: {{date}}\n\n{{transcript}}",
 	},
+	feedCache: {
+		enabled: true,
+		ttlHours: 6,
+	},
 };

src/main.ts

@@ -1,70 +1,88 @@
+import { ItemView, Notice, Plugin, TFile, WorkspaceLeaf } from "obsidian";
+import { get } from "svelte/store";
 import {
+	episodeCache,
 	currentEpisode,
 	downloadedEpisodes,
 	favorites,
 	localFiles,
 	playedEpisodes,
 	playlists,
+	plugin,
 	queue,
 	savedFeeds,
-} from "src/store";
-import { Plugin, type WorkspaceLeaf } from "obsidian";
-import { API } from "src/API/API";
-import type { IAPI } from "src/API/IAPI";
-import { DEFAULT_SETTINGS, VIEW_TYPE } from "src/constants";
-import { PodNotesSettingsTab } from "src/ui/settings/PodNotesSettingsTab";
-import { MainView } from "src/ui/PodcastView";
-import type { IPodNotesSettings } from "./types/IPodNotesSettings";
-import { plugin } from "./store";
+} from "./store/index";
+import PodcastView from "./ui/PodcastView/PodcastView.svelte";
+import {
+	DEFAULT_SETTINGS,
+	type PodNotesSettings,
+} from "./settings/PodNotesSettings";
+import {
+	downloadEpisode,
+	type DownloadedEpisode,
+} from "./downloadEpisode";
+import { PodNotesSettingsTab } from "./ui/settings/PodNotesSettingsTab";
+import { API } from "./API";
+import type { Episode } from "./types/Episode";
 import type { IPodNotes } from "./types/IPodNotes";
-import { EpisodeStatusController } from "./store_controllers/EpisodeStatusController";
-import type { StoreController } from "./types/StoreController";
-import type { PlayedEpisode } from "./types/PlayedEpisode";
-import type { PodcastFeed } from "./types/PodcastFeed";
+import { getContextMenuHandler } from "./getContextMenuHandler";
+import { podNotesURIHandler } from "./podNotesURIHandler";
+import type { Playlist } from "./types/Playlists";
+import { StoreController } from "./types/StoreController";
 import { SavedFeedsController } from "./store_controllers/SavedFeedsController";
-import type { Playlist } from "./types/Playlist";
 import { PlaylistController } from "./store_controllers/PlaylistController";
 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 { TimestampTemplateEngine } from "./TemplateEngine";
-import createPodcastNote from "./createPodcastNote";
-import downloadEpisodeWithNotice from "./downloadEpisode";
-import type DownloadedEpisode from "./types/DownloadedEpisode";
-import DownloadedEpisodesController from "./store_controllers/DownloadedEpisodesController";
 import { LocalFilesController } from "./store_controllers/LocalFilesController";
-import type PartialAppExtension from "./global";
-import podNotesURIHandler from "./URIHandler";
-import getContextMenuHandler from "./getContextMenuHandler";
-import getUniversalPodcastLink from "./getUniversalPodcastLink";
-import type { IconType } from "./types/IconType";
+import { DownloadedEpisodesController } from "./store_controllers/DownloadedEpisodesController";
+import { CurrentEpisodeController } from "./store_controllers/CurrentEpisodeController";
+import { EpisodeStatusController } from "./store_controllers/EpisodeStatusController";
 import { TranscriptionService } from "./services/TranscriptionService";
+import type { IconType } from "./types/IconType";
 
-export default class PodNotes extends Plugin implements IPodNotes {
-	public api!: IAPI;
-	public settings!: IPodNotesSettings;
-	public override app!: PartialAppExtension;
+export const VIEW_TYPE = "pod-notes-view";
 
-	private view: MainView | null = null;
+class MainView extends ItemView {
+	view: PodcastView;
+	plugin: PodNotes;
 
-	private playedEpisodeController?: StoreController<{
-		[episodeName: string]: PlayedEpisode;
-	}>;
-	private savedFeedsController?: StoreController<{
-		[podcastName: string]: PodcastFeed;
-	}>;
-	private playlistController?: StoreController<{
-		[playlistName: string]: Playlist;
-	}>;
+	constructor(leaf: WorkspaceLeaf, plugin: PodNotes) {
+		super(leaf);
+		this.plugin = plugin;
+	}
+
+	override getViewType(): string {
+		return VIEW_TYPE;
+	}
+
+	override getDisplayText(): string {
+		return "PodNotes";
+	}
+
+	override async onOpen(): Promise<void> {
+		this.view = new PodcastView({
+			target: this.contentEl,
+			props: {},
+		});
+	}
+}
+
+export default class PodNotes extends Plugin implements IPodNotes {
+	settings!: PodNotesSettings;
+	view?: MainView;
+	api!: API;
+
+	private playedEpisodeController?: StoreController<Episode[]>;
+	private savedFeedsController?: StoreController<{ [podcast: string]: string }>;
+	private playlistController?: StoreController<{ [key: string]: Playlist }>;
 	private queueController?: StoreController<Playlist>;
 	private favoritesController?: StoreController<Playlist>;
 	private localFilesController?: StoreController<Playlist>;
 	private currentEpisodeController?: StoreController<Episode>;
 	private downloadedEpisodesController?: StoreController<{
 		[podcastName: string]: DownloadedEpisode[];
 	}>;
-	private transcriptionService!: TranscriptionService;
+	private transcriptionService?: TranscriptionService;
 
 	private maxLayoutReadyAttempts = 10;
 	private layoutReadyAttempts = 0;
@@ -103,27 +121,25 @@ export default class PodNotes extends Plugin implements IPodNotes {
 			this,
 		).on();
 
-		this.transcriptionService = new TranscriptionService(this);
-
 		this.api = new API();
 
 		this.addCommand({
 			id: "podnotes-show-leaf",
 			name: "Show PodNotes",
 			icon: "podcast" as IconType,
-				checkCallback: function (this: PodNotes, checking: boolean) {
-					if (checking) {
-						return !this.app.workspace.getLeavesOfType(VIEW_TYPE).length;
-					}
+			checkCallback: function (this: PodNotes, checking: boolean) {
+				if (checking) {
+					return !this.app.workspace.getLeavesOfType(VIEW_TYPE).length;
+				}
 
-					const leaf = this.app.workspace.getRightLeaf(false);
-					if (leaf) {
-						leaf.setViewState({
-							type: VIEW_TYPE,
-						});
-					}
-				}.bind(this),
-			});
+				const leaf = this.app.workspace.getRightLeaf(false);
+				if (leaf) {
+					leaf.setViewState({
+						type: VIEW_TYPE,
+					});
+				}
+			}.bind(this),
+		});
 
 		this.addCommand({
 			id: "start-playing",
@@ -140,137 +156,129 @@ export default class PodNotes extends Plugin implements IPodNotes {
 
 		this.addCommand({
 			id: "stop-playing",
-			name: "Stop Podcast",
+			name: "Stop playing Podcast",
 			icon: "stop-circle" as IconType,
 			checkCallback: (checking) => {
 				if (checking) {
-					return this.api.isPlaying && !!this.api.podcast;
+					return this.api.isPlaying;
 				}
 
 				this.api.stop();
 			},
 		});
 
 		this.addCommand({
-			id: "skip-backward",
-			name: "Skip Backward",
-			icon: "skip-back" as IconType,
-			checkCallback: (checking) => {
-				if (checking) {
-					return this.api.isPlaying && !!this.api.podcast;
-				}
+			id: "podnotes-add-timestamp",
+			name: "Add Timestamp",
+			callback: () => this.api.addTimestamp(),
+		});
 
-				this.api.skipBackward();
+		this.addCommand({
+			id: "podnotes-paste-timestamp-template",
+			name: "Paste Timestamp Template",
+			editorCallback: (editor) => {
+				const cursor = editor.getCursor();
+				editor.replaceRange("{{timestamp}}", cursor, cursor);
 			},
 		});
 
 		this.addCommand({
-			id: "skip-forward",
-			name: "Skip Forward",
-			icon: "skip-forward" as IconType,
+			id: "podnotes-playlist-clear",
+			name: "Clear current playlist",
 			checkCallback: (checking) => {
 				if (checking) {
-					return this.api.isPlaying && !!this.api.podcast;
+					return this.api.playlist.length > 0;
 				}
 
-				this.api.skipForward();
+				this.api.clearPlaylist();
 			},
 		});
 
 		this.addCommand({
-			id: "download-playing-episode",
-			name: "Download Playing Episode",
-			icon: "download" as IconType,
+			id: "podnotes-playlist-shuffle",
+			name: "Shuffle current playlist",
 			checkCallback: (checking) => {
 				if (checking) {
-					return !!this.api.podcast;
+					return this.api.playlist.length > 1;
 				}
 
-				const episode = this.api.podcast;
-				downloadEpisodeWithNotice(episode, this.settings.download.path);
-			},
-		});
-
-		this.addCommand({
-			id: "hrpn",
-			name: "Reload PodNotes",
-			callback: () => {
-				const id = this.manifest.id;
-
-				this.app.plugins
-					.disablePlugin(id)
-					.then(() => this.app.plugins.enablePlugin(id));
+				this.api.shufflePlaylist();
 			},
 		});
 
 		this.addCommand({
-			id: "capture-timestamp",
-			name: "Capture Timestamp",
-			icon: "clock" as IconType,
-			editorCheckCallback: (checking, editor, view) => {
+			id: "podnotes-playlist-save-local",
+			name: "Save local playlist",
+			checkCallback: (checking) => {
 				if (checking) {
-					return !!this.api.podcast && !!this.settings.timestamp.template;
+					return this.api.playlist.length > 0;
 				}
 
-				const cursorPos = editor.getCursor();
-				const capture = TimestampTemplateEngine(
-					this.settings.timestamp.template,
-				);
-
-				editor.replaceRange(capture, cursorPos);
-				editor.setCursor(cursorPos.line, cursorPos.ch + capture.length);
+				this.api.saveLocalPlaylist();
 			},
 		});
 
 		this.addCommand({
-			id: "create-podcast-note",
-			name: "Create Podcast Note",
-			icon: "file-plus" as IconType,
+			id: "podnotes-playlist-save-favorites",
+			name: "Save favorites playlist",
 			checkCallback: (checking) => {
 				if (checking) {
-					return (
-						!!this.api.podcast &&
-						!!this.settings.note.path &&
-						!!this.settings.note.template
-					);
+					return this.api.playlist.length > 0;
 				}
 
-				createPodcastNote(this.api.podcast);
+				this.api.saveFavoritesPlaylist();
 			},
 		});
 
 		this.addCommand({
-			id: "get-share-link-episode",
-			name: "Copy universal episode link to clipboard",
-			icon: "share" as IconType,
+			id: "podnotes-download-episode",
+			name: "Download Episode",
 			checkCallback: (checking) => {
+				const episode = this.api.podcast;
 				if (checking) {
-					return !!this.api.podcast;
+					return !!episode;
 				}
 
-				getUniversalPodcastLink(this.api);
+				if (!episode) {
+					return;
+				}
+
+				const episodeFileName = episode.episodeFilename || episode.title;
+				const episodePath = `${this.settings.downloadPath}/${episode.podcastName}/${episodeFileName}.mp3`;
+
+				this.app.vault.adapter.exists(episodePath).then(async (exists) => {
+					if (exists) {
+						new Notice(
+							`Episode ${episode.title} already exists. Skipping.`,
+						);
+					} else {
+						new Notice(`Downloading episode ${episode.title}...`);
+						const file = await downloadEpisode(episode, this);
+						new Notice(
+							`Episode ${episode.title} downloaded to ${file.path}`,
+						);
+					}
+				});
 			},
 		});
 
 		this.addCommand({
-			id: "podnotes-toggle-playback",
-			name: "Toggle playback",
-			icon: "play" as IconType,
+			id: "podnotes-transcribe",
+			name: "Transcribe current episode",
 			checkCallback: (checking) => {
+				const canTranscribe =
+					!!this.api.podcast && !!this.settings.openAIApiKey?.trim();
+
 				if (checking) {
-					return !!this.api.podcast;
+					return canTranscribe;
 				}
 
-				this.api.togglePlayback();
+				if (canTranscribe) {
+					void this.getTranscriptionService().transcribeCurrentEpisode();
+				}
 			},
 		});
 
-		this.addCommand({
-			id: "podnotes-transcribe",
-			name: "Transcribe current episode",
-			callback: () => this.transcriptionService.transcribeCurrentEpisode(),
-		});
-
 		this.addSettingTab(new PodNotesSettingsTab(this.app, this));
 
 		this.registerView(VIEW_TYPE, (leaf: WorkspaceLeaf) => {
@@ -314,6 +322,14 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		}
 	}
 
+	private getTranscriptionService(): TranscriptionService {
+		if (!this.transcriptionService) {
+			this.transcriptionService = new TranscriptionService(this);
+		}
+
+		return this.transcriptionService;
+	}
+
 	override onunload() {
 		this.playedEpisodeController?.off();
 		this.savedFeedsController?.off();