@rixl/media-core 1.0.2 → 1.1.1

package/dist/store/player-store.d.ts

@@ -1,94 +0,0 @@
-import { SubtitleTrack } from "../lib/subtitle-logic.js";
-import { AudioTrack } from "../lib/hls-utils.js";
-import { UUID } from "../types/uuid.js";
-import { MapStore } from "nanostores";
-import Hls from "hls.js";
-export interface PlayerState {
-  paused: boolean;
-  loading: boolean;
-  ended: boolean;
-  mounted: boolean;
-  hasInteracted: boolean;
-  whenInteracted: Date;
-  isFullscreen: boolean;
-  isPictureInPicture: boolean;
-  muted: boolean;
-  playbackRate: number;
-  volume: number;
-  previousVolume: number;
-  viewport: {
-    width: number;
-    height: number;
-  };
-  resolution: number;
-  subtitleTrack: number;
-  availableSubtitleTracks: SubtitleTrack[];
-  currentSubtitleText: string;
-  audioTrack: number;
-  availableAudioTracks: AudioTrack[];
-  hlsInstance: Hls | null;
-}
-export interface PlayerProgressSnapshot {
-  currentTime: number;
-  duration: number;
-  progress: number;
-  buffered: number;
-}
-export interface PlayerStateStore {
-  state: Map<UUID, MapStore<PlayerState>>;
-  get: (id: UUID) => MapStore<PlayerState>;
-  deletePlayer: (id: UUID) => void;
-  getEffectiveMediaMuted: (player: Pick<PlayerState, "muted" | "volume" | "hasInteracted">) => boolean;
-  muteMedia: (id: UUID) => void;
-  unmuteMedia: (id: UUID) => void;
-  toggleMediaMute: (id: UUID) => void;
-  setMediaVolume: (id: UUID, volume: number) => void;
-  playMedia: (id: UUID) => Promise<void>;
-  pauseMedia: (id: UUID) => void;
-  toggleMediaPlayback: (id: UUID) => Promise<void>;
-  pauseOtherMedia: (except: UUID) => void;
-  setMediaPlaybackRate: (id: UUID, playbackRate: number) => void;
-  readProgressSnapshot: (id: UUID) => PlayerProgressSnapshot;
-  subscribeToProgress: (id: UUID, onStoreChange: () => void) => () => void;
-  seekProgressTo: (id: UUID, seconds: number) => void;
-  seekProgressBy: (id: UUID, deltaSeconds: number) => void;
-  getTrackOptions: (tracks: {
-    label: string;
-    language: string;
-    kind: string;
-  }[]) => {
-    index: number;
-    label: string;
-    language: string;
-    kind: string;
-  }[];
-  selectAudioTrack: (id: UUID, trackIndex: number) => void;
-  selectSubtitleTrack: (id: UUID, trackIndex: number) => void;
-  setAudioTrack: (id: UUID, audioTrack: number) => void;
-  setAvailableAudioTracks: (id: UUID, tracks: AudioTrack[]) => void;
-  setGlobalMuted: (muted: boolean) => void;
-  setGlobalVolume: (volume: number) => void;
-  setGlobalPlaybackRate: (rate: number) => void;
-  setGlobalPreferredQuality: (quality: number | undefined) => void;
-  setGlobalPreferredAudioLanguage: (language: string | undefined) => void;
-  setGlobalPreferredSubtitleLanguage: (language: string | undefined) => void;
-  pauseAllPlayers: () => void;
-  setMounted: (id: UUID) => void;
-  setHasInteracted: (id: UUID) => void;
-  setPaused: (id: UUID, paused: boolean) => void;
-  setLoading: (id: UUID, loading: boolean) => void;
-  setEnded: (id: UUID, ended: boolean) => void;
-  setFullscreen: (id: UUID, isFullscreen: boolean) => void;
-  setPictureInPicture: (id: UUID, isPictureInPicture: boolean) => void;
-  setMuted: (id: UUID, muted: boolean) => void;
-  setPlaybackRate: (id: UUID, playbackRate: number) => void;
-  setPreviousVolume: (id: UUID, previousVolume: number) => void;
-  setVolume: (id: UUID, volume: number) => void;
-  setViewport: (id: UUID, width: number, height: number) => void;
-  setResolution: (id: UUID, resolution: number) => void;
-  setSubtitleTrack: (id: UUID, subtitleTrack: number) => void;
-  setAvailableSubtitleTracks: (id: UUID, tracks: SubtitleTrack[]) => void;
-  setCurrentSubtitleText: (id: UUID, text: string) => void;
-  setHlsInstance: (id: UUID, hlsInstance: Hls | null) => void;
-}
-export declare const playerStateStore: PlayerStateStore;

package/dist/store/player-store.js

@@ -1,127 +0,0 @@
-import { getPersistedSubtitleTrack, persistSubtitleTrack } from "../lib/track-persistence.js";
-import { clamp } from "../lib/numbers.js";
-import { clampVolume } from "../lib/volume-utils.js";
-import { playerGlobalActions } from "./player-global-actions.js";
-import { playerStateActions } from "./player-store-actions.js";
-import { playerTrackActions } from "./player-track-actions.js";
-import { settingsStore } from "./settings/store.js";
-import { map } from "nanostores";
-
-// src/store/player-store.ts
-const MIN_PLAYBACK_RATE = .25;
-const MAX_PLAYBACK_RATE = 3;
-const createInitialPlayerState = () => {
-	const settings = settingsStore.getSettings();
-	const initialVolume = settings.volume;
-	return {
-		paused: true,
-		loading: true,
-		ended: false,
-		mounted: false,
-		hasInteracted: false,
-		whenInteracted: /* @__PURE__ */ new Date(0),
-		isFullscreen: false,
-		isPictureInPicture: false,
-		muted: settings.globalMutedPreference,
-		playbackRate: clamp(settings.playbackSpeed, MIN_PLAYBACK_RATE, MAX_PLAYBACK_RATE),
-		volume: initialVolume,
-		previousVolume: initialVolume,
-		viewport: {
-			width: 0,
-			height: 0
-		},
-		resolution: -1,
-		subtitleTrack: getPersistedSubtitleTrack(),
-		availableSubtitleTracks: [],
-		currentSubtitleText: "",
-		audioTrack: 0,
-		availableAudioTracks: [],
-		hlsInstance: null
-	};
-};
-const createInitialPlayer = () => map(createInitialPlayerState());
-function setPlayerValue(playerId, key, value) {
-	playerStateStore.get(playerId).setKey(key, value);
-}
-const playerStateStore = {
-	state: /* @__PURE__ */ new Map(),
-	get: (id) => {
-		let player = playerStateStore.state.get(id);
-		if (!player) {
-			player = createInitialPlayer();
-			playerStateStore.state.set(id, player);
-		}
-		return player;
-	},
-	deletePlayer: (id) => {
-		playerStateStore.state.delete(id);
-	},
-	...playerStateActions,
-	...playerTrackActions,
-	...playerGlobalActions,
-	setMounted: (id) => {
-		setPlayerValue(id, "mounted", true);
-	},
-	setHasInteracted: (id) => {
-		const player = playerStateStore.get(id);
-		player.setKey("hasInteracted", true);
-		player.setKey("whenInteracted", /* @__PURE__ */ new Date());
-	},
-	setPaused: (id, paused) => {
-		setPlayerValue(id, "paused", paused);
-	},
-	setLoading: (id, loading) => {
-		setPlayerValue(id, "loading", loading);
-	},
-	setEnded: (id, ended) => {
-		setPlayerValue(id, "ended", ended);
-	},
-	setFullscreen: (id, isFullscreen) => {
-		setPlayerValue(id, "isFullscreen", isFullscreen);
-	},
-	setPictureInPicture: (id, isPictureInPicture) => {
-		setPlayerValue(id, "isPictureInPicture", isPictureInPicture);
-	},
-	setMuted: (id, muted) => {
-		setPlayerValue(id, "muted", muted);
-	},
-	setPlaybackRate: (id, playbackRate) => {
-		setPlayerValue(id, "playbackRate", clamp(playbackRate, MIN_PLAYBACK_RATE, MAX_PLAYBACK_RATE));
-	},
-	setPreviousVolume: (id, previousVolume) => {
-		setPlayerValue(id, "previousVolume", clampVolume(previousVolume));
-	},
-	setVolume: (id, volume) => {
-		setPlayerValue(id, "volume", clampVolume(volume));
-	},
-	setViewport: (id, width, height) => {
-		setPlayerValue(id, "viewport", {
-			width,
-			height
-		});
-	},
-	setResolution: (id, resolution) => {
-		setPlayerValue(id, "resolution", resolution);
-	},
-	setSubtitleTrack: (id, subtitleTrack) => {
-		const player = playerStateStore.get(id);
-		player.get().availableSubtitleTracks.forEach((track, index) => {
-			track.track.mode = index === subtitleTrack ? "showing" : "disabled";
-		});
-		player.setKey("subtitleTrack", subtitleTrack);
-		persistSubtitleTrack(subtitleTrack);
-	},
-	setAvailableSubtitleTracks: (id, tracks) => {
-		playerStateStore.get(id).setKey("availableSubtitleTracks", tracks);
-		const persistedTrack = getPersistedSubtitleTrack();
-		if (persistedTrack >= 0 && persistedTrack < tracks.length) playerStateStore.setSubtitleTrack(id, persistedTrack);
-	},
-	setCurrentSubtitleText: (id, text) => {
-		setPlayerValue(id, "currentSubtitleText", text);
-	},
-	setHlsInstance: (id, hlsInstance) => {
-		setPlayerValue(id, "hlsInstance", hlsInstance);
-	}
-};
-
-export { createInitialPlayerState, playerStateStore };

package/dist/store/player-track-actions.js

@@ -1,44 +0,0 @@
-import { getPersistedAudioTrack, persistAudioTrack } from "../lib/track-persistence.js";
-
-// src/store/player-track-actions.ts
-const EMPTY_TRACKS = [];
-function toTrackOption(track, index) {
-	return {
-		index,
-		label: track.label,
-		language: track.language,
-		kind: track.kind
-	};
-}
-const playerTrackActions = {
-	getTrackOptions(tracks) {
-		return tracks.length > 0 ? tracks.map(toTrackOption) : EMPTY_TRACKS;
-	},
-	selectAudioTrack(id, trackIndex) {
-		const { availableAudioTracks } = this.get(id).get();
-		if (trackIndex < 0 || trackIndex >= availableAudioTracks.length) return;
-		this.setAudioTrack(id, trackIndex);
-	},
-	selectSubtitleTrack(id, trackIndex) {
-		if (trackIndex !== -1) {
-			const { availableSubtitleTracks } = this.get(id).get();
-			if (trackIndex < 0 || trackIndex >= availableSubtitleTracks.length) return;
-		}
-		this.setSubtitleTrack(id, trackIndex);
-	},
-	setAudioTrack(id, audioTrack) {
-		const player = this.get(id);
-		const currentState = player.get();
-		if (currentState.hlsInstance && currentState.hlsInstance.audioTracks && audioTrack >= 0 && audioTrack < currentState.hlsInstance.audioTracks.length) currentState.hlsInstance.audioTrack = audioTrack;
-		player.setKey("audioTrack", audioTrack);
-		persistAudioTrack(audioTrack);
-	},
-	setAvailableAudioTracks(id, tracks) {
-		this.get(id).setKey("availableAudioTracks", tracks);
-		const persistedTrack = getPersistedAudioTrack();
-		if (persistedTrack >= 0 && persistedTrack < tracks.length) this.setAudioTrack(id, persistedTrack);
-		else if (tracks.length > 0) this.setAudioTrack(id, 0);
-	}
-};
-
-export { playerTrackActions };

package/dist/store/postStore.d.ts

@@ -1,20 +0,0 @@
-import { FeedPost } from "../types/feed.js";
-import { WritableAtom } from "nanostores";
-export interface PostStoreState {
-  initialized: boolean;
-  feedId: string;
-  posts: FeedPost[];
-  isLoadedInitial: boolean;
-  isFetchingVideos: boolean;
-  currentIndex: number;
-  total: number;
-}
-export declare const postStore: WritableAtom<PostStoreState>;
-interface PostStoreActions {
-  init: (feedId: string) => void;
-  loadInitialPosts: () => Promise<void>;
-  fetchNewVideos: () => Promise<void>;
-  setCurrentIndex: (index: number) => void;
-}
-export declare const postStoreActions: PostStoreActions;
-export {};

package/dist/store/postStore.js

@@ -1,112 +0,0 @@
-import { getFeedPosts } from "./feed-store.js";
-import { feedCacheStore } from "./feed-cache-store.js";
-import { atom } from "nanostores";
-
-// src/store/postStore.ts
-const postStore = atom({
-	initialized: false,
-	feedId: "",
-	posts: [],
-	isLoadedInitial: true,
-	isFetchingVideos: false,
-	currentIndex: 0,
-	total: 0
-});
-/**
-* Identifies the feed a request belongs to.
-*
-* The feed id alone is not enough: switching away and back (A -> B -> A) would
-* let a response from the first visit be accepted on the second, merging posts
-* against a queue that has since been rebuilt. The counter, bumped on every
-* init, keeps each visit distinct.
-*/
-let feedEpoch = 0;
-/** Whether the request that started under this epoch still owns the store. */
-function isCurrent(epoch) {
-	return epoch === feedEpoch;
-}
-const postStoreActions = {
-	init(feedId) {
-		feedEpoch += 1;
-		const cachedPosts = feedCacheStore.loadCache(feedId);
-		postStore.set({
-			...postStore.get(),
-			feedId,
-			initialized: true,
-			posts: cachedPosts,
-			currentIndex: 0,
-			total: 0,
-			isLoadedInitial: cachedPosts.length > 0,
-			isFetchingVideos: false
-		});
-	},
-	async loadInitialPosts() {
-		const state = postStore.get();
-		if (state.isFetchingVideos) return;
-		const epoch = feedEpoch;
-		const feedId = state.feedId;
-		postStore.set({
-			...state,
-			isFetchingVideos: true
-		});
-		try {
-			const currentState = postStore.get();
-			const apiPosts = await getFeedPosts(feedId);
-			if (!isCurrent(epoch)) return;
-			const allPosts = [...currentState.posts, ...apiPosts.posts];
-			const uniquePosts = Array.from(new Map(allPosts.map((post) => [post.id, post])).values());
-			feedCacheStore.saveNewPosts(apiPosts.posts, feedId);
-			postStore.set({
-				...postStore.get(),
-				posts: uniquePosts,
-				isLoadedInitial: true,
-				total: apiPosts.total
-			});
-		} catch (error) {
-			console.error("[PostStore] Error loading posts:", error);
-		} finally {
-			if (isCurrent(epoch)) postStore.set({
-				...postStore.get(),
-				isFetchingVideos: false
-			});
-		}
-	},
-	async fetchNewVideos() {
-		const state = postStore.get();
-		if (state.isFetchingVideos || !state.initialized) return;
-		const epoch = feedEpoch;
-		const feedId = state.feedId;
-		postStore.set({
-			...state,
-			isFetchingVideos: true
-		});
-		try {
-			const currentState = postStore.get();
-			const apiPosts = await getFeedPosts(feedId, currentState.posts ? currentState.posts.length : 0);
-			if (!isCurrent(epoch)) return;
-			postStore.set({
-				...postStore.get(),
-				posts: [...postStore.get().posts, ...apiPosts.posts],
-				total: apiPosts.total
-			});
-		} finally {
-			if (isCurrent(epoch)) postStore.set({
-				...postStore.get(),
-				isFetchingVideos: false
-			});
-		}
-	},
-	setCurrentIndex(index) {
-		const currentState = postStore.get();
-		if (index !== currentState.currentIndex) {
-			const currentVideo = currentState.posts[currentState.currentIndex];
-			if (currentVideo) feedCacheStore.removePost(currentVideo.id);
-			postStore.set({
-				...currentState,
-				currentIndex: index
-			});
-		}
-	}
-};
-
-export { postStore, postStoreActions };

package/dist/store/settings/constants.d.ts

@@ -1,15 +0,0 @@
-export declare const FONT_FAMILIES: {
-  readonly monospace_serif: "\"Courier New\", Courier, \"Nimbus Mono L\", \"Cutive Mono\", monospace";
-  readonly proportional_serif: "\"Times New Roman\", Times, Georgia, Cambria, \"PT Serif Caption\", serif";
-  readonly monospace_sans: "\"Deja Vu Sans Mono\", \"Lucida Console\", Monaco, Consolas, \"PT Mono\", monospace";
-  readonly proportional_sans: "Roboto, Arial, Helvetica, Verdana, \"PT Sans Caption\", sans-serif";
-  readonly casual: "\"Comic Sans MS\", Impact, Handlee, fantasy";
-  readonly cursive: "\"Monotype Corsiva\", \"URW Chancery L\", \"Apple Chancery\", \"Dancing Script\", cursive";
-  readonly small_caps: "Arial, Helvetica, Verdana, \"Marcellus SC\", sans-serif";
-};
-export type FontFamilyKey = keyof typeof FONT_FAMILIES;
-export declare const FONT_SIZES: number[];
-export declare const COLORS: Record<string, string>;
-export declare const EDGE_STYLES: string[];
-export declare const PLAYBACK_SPEEDS: number[];
-export declare const LANG_TYPES: string[];

package/dist/store/settings/constants.js

@@ -1,47 +0,0 @@
-// src/store/settings/constants.ts
-const FONT_FAMILIES = {
-	monospace_serif: "\"Courier New\", Courier, \"Nimbus Mono L\", \"Cutive Mono\", monospace",
-	proportional_serif: "\"Times New Roman\", Times, Georgia, Cambria, \"PT Serif Caption\", serif",
-	monospace_sans: "\"Deja Vu Sans Mono\", \"Lucida Console\", Monaco, Consolas, \"PT Mono\", monospace",
-	proportional_sans: "Roboto, Arial, Helvetica, Verdana, \"PT Sans Caption\", sans-serif",
-	casual: "\"Comic Sans MS\", Impact, Handlee, fantasy",
-	cursive: "\"Monotype Corsiva\", \"URW Chancery L\", \"Apple Chancery\", \"Dancing Script\", cursive",
-	small_caps: "Arial, Helvetica, Verdana, \"Marcellus SC\", sans-serif"
-};
-const FONT_SIZES = [
-	50,
-	100,
-	150,
-	200
-];
-const COLORS = {
-	white: "#ffffff",
-	yellow: "#ffff00",
-	green: "#00ff00",
-	cyan: "#00ffff",
-	blue: "#0000ff",
-	magenta: "#ff00ff",
-	red: "#ff0000",
-	black: "#000000"
-};
-const EDGE_STYLES = [
-	"none",
-	"drop-shadow",
-	"raised",
-	"depressed",
-	"outline"
-];
-const PLAYBACK_SPEEDS = [
-	1,
-	1.25,
-	1.5,
-	2,
-	3
-];
-const LANG_TYPES = [
-	"off",
-	"eng",
-	"auto"
-];
-
-export { COLORS, EDGE_STYLES, FONT_FAMILIES, FONT_SIZES, LANG_TYPES, PLAYBACK_SPEEDS };

package/dist/store/settings/defaults.d.ts

@@ -1,2 +0,0 @@
-import { SettingsState } from "./types.js";
-export declare const defaultSettings: SettingsState;

package/dist/store/settings/defaults.js

@@ -1,24 +0,0 @@
-// src/store/settings/defaults.ts
-const defaultSettings = {
-	volume: 1,
-	playbackSpeed: 1,
-	customPlayback: 1,
-	allowCaptions: false,
-	captionPosition: {
-		x: 20,
-		y: 90
-	},
-	captionLang: "off",
-	captionFontFamily: "proportional_sans",
-	captionFontSize: 100,
-	captionFontColor: "#ffffff",
-	captionFontOpacity: 100,
-	captionBGColor: "#000000",
-	captionBGOpacity: 75,
-	captionWindowColor: "#000000",
-	captionWindowOpacity: 0,
-	captionCharacterEdgeStyle: "none",
-	globalMutedPreference: false
-};
-
-export { defaultSettings };

package/dist/store/settings/storage.d.ts

@@ -1,3 +0,0 @@
-import { SettingsState } from "./types.js";
-export declare const loadSettings: () => SettingsState;
-export declare const saveSettings: (settings: SettingsState) => void;

package/dist/store/settings/storage.js

@@ -1,28 +0,0 @@
-import { defaultSettings } from "./defaults.js";
-import { validateSettings } from "./validation.js";
-
-// src/store/settings/storage.ts
-const SETTINGS_STORAGE_KEY = "videosdk_settings";
-const loadSettings = () => {
-	if (typeof window === "undefined") return defaultSettings;
-	try {
-		const storedSettings = localStorage.getItem(SETTINGS_STORAGE_KEY);
-		if (storedSettings) {
-			const parsedSettings = JSON.parse(storedSettings);
-			return validateSettings(parsedSettings);
-		}
-	} catch (error) {
-		console.error("Failed to load settings from localStorage:", error);
-	}
-	return defaultSettings;
-};
-const saveSettings = (settings) => {
-	if (typeof window === "undefined") return;
-	try {
-		localStorage.setItem(SETTINGS_STORAGE_KEY, JSON.stringify(settings));
-	} catch (error) {
-		console.error("Failed to save settings to localStorage:", error);
-	}
-};
-
-export { loadSettings, saveSettings };

package/dist/store/settings/store.d.ts

@@ -1,32 +0,0 @@
-import { CaptionLangType, SettingsState } from "./types.js";
-import { MapStore } from "nanostores";
-interface SettingsStore {
-  state: MapStore<SettingsState>;
-  getSettings: () => SettingsState;
-  setVolume: (volume: number) => number;
-  setPlaybackSpeed: (playbackSpeed: number) => number;
-  setCustomPlayback: (customPlayback: number) => number;
-  setAllowCaptions: (allowCaptions: boolean) => boolean;
-  setCaptionPosition: (x: number, y: number) => {
-    x: number;
-    y: number;
-  };
-  setSubtitleLang: (captionLang: CaptionLangType) => CaptionLangType;
-  setCaptionFontFamily: (captionFontFamily: string) => string;
-  setCaptionFontSize: (captionFontSize: number) => number;
-  setCaptionFontColor: (captionFontColor: string) => string;
-  setCaptionBGColor: (captionBGColor: string) => string;
-  setCaptionBGOpacity: (captionOpacity: number) => number;
-  setCaptionWindowColor: (captionWindowColor: string) => string;
-  setCaptionWindowOpacity: (captionWindowOpacity: number) => number;
-  setCaptionFontOpacity: (captionFontOpacity: number) => number;
-  setCaptionCharacterEdgeStyle: (captionCharacterEdgeStyle: string) => string;
-  resetCaptionSettings: () => void;
-  setSelectedLanguageCode: (languageCode: string) => string | undefined;
-  setMuted: (muted: boolean) => boolean;
-  setPreferredQuality: (quality: number | undefined) => number | undefined;
-  setPreferredAudioLanguage: (language: string | undefined) => string | undefined;
-  setPreferredSubtitleLanguage: (language: string | undefined) => string | undefined;
-}
-export declare const settingsStore: SettingsStore;
-export {};

package/dist/store/settings/store.js

@@ -1,59 +0,0 @@
-import { defaultSettings } from "./defaults.js";
-import { loadSettings, saveSettings } from "./storage.js";
-import { clampVolume } from "../../lib/volume-utils.js";
-import { map } from "nanostores";
-
-// src/store/settings/store.ts
-const updateSettings = (key, value) => {
-	settingsStore.state.setKey(key, value);
-	saveSettings(settingsStore.state.get());
-	return value;
-};
-const settingsState = map(loadSettings());
-const settingsStore = {
-	state: settingsState,
-	getSettings: () => settingsStore.state.get(),
-	setVolume: (volume) => updateSettings("volume", clampVolume(volume)),
-	setPlaybackSpeed: (playbackSpeed) => updateSettings("playbackSpeed", playbackSpeed),
-	setCustomPlayback: (customPlayback) => updateSettings("customPlayback", customPlayback),
-	setAllowCaptions: (allowCaptions) => updateSettings("allowCaptions", allowCaptions),
-	setCaptionPosition: (x, y) => updateSettings("captionPosition", {
-		x,
-		y
-	}),
-	setSubtitleLang: (captionLang) => updateSettings("captionLang", captionLang),
-	setCaptionFontFamily: (captionFontFamily) => updateSettings("captionFontFamily", captionFontFamily),
-	setCaptionFontSize: (captionFontSize) => updateSettings("captionFontSize", captionFontSize),
-	setCaptionFontColor: (captionFontColor) => updateSettings("captionFontColor", captionFontColor),
-	setCaptionBGColor: (captionBGColor) => updateSettings("captionBGColor", captionBGColor),
-	setCaptionBGOpacity: (captionOpacity) => updateSettings("captionBGOpacity", captionOpacity),
-	setCaptionWindowColor: (captionWindowColor) => updateSettings("captionWindowColor", captionWindowColor),
-	setCaptionWindowOpacity: (captionWindowOpacity) => updateSettings("captionWindowOpacity", captionWindowOpacity),
-	setCaptionFontOpacity: (captionFontOpacity) => updateSettings("captionFontOpacity", captionFontOpacity),
-	setCaptionCharacterEdgeStyle: (captionCharacterEdgeStyle) => updateSettings("captionCharacterEdgeStyle", captionCharacterEdgeStyle),
-	resetCaptionSettings: () => {
-		const resetSettings = {
-			...settingsStore.state.get(),
-			captionPosition: defaultSettings.captionPosition,
-			captionLang: defaultSettings.captionLang,
-			captionFontFamily: defaultSettings.captionFontFamily,
-			captionFontSize: defaultSettings.captionFontSize,
-			captionFontColor: defaultSettings.captionFontColor,
-			captionBGColor: defaultSettings.captionBGColor,
-			captionBGOpacity: defaultSettings.captionBGOpacity,
-			captionWindowColor: defaultSettings.captionWindowColor,
-			captionWindowOpacity: defaultSettings.captionWindowOpacity,
-			captionFontOpacity: defaultSettings.captionFontOpacity,
-			captionCharacterEdgeStyle: defaultSettings.captionCharacterEdgeStyle
-		};
-		settingsStore.state.set(resetSettings);
-		saveSettings(resetSettings);
-	},
-	setSelectedLanguageCode: (languageCode) => updateSettings("selectedLanguageCode", languageCode),
-	setMuted: (muted) => updateSettings("globalMutedPreference", muted),
-	setPreferredQuality: (quality) => updateSettings("preferredQuality", quality),
-	setPreferredAudioLanguage: (language) => updateSettings("preferredAudioLanguage", language),
-	setPreferredSubtitleLanguage: (language) => updateSettings("preferredSubtitleLanguage", language)
-};
-
-export { settingsStore };

package/dist/store/settings/types.d.ts

@@ -1,27 +0,0 @@
-export type VideoTheme = "default" | "minimal" | "feed" | "hover" | "hideUI";
-export type CaptionLangType = "off" | "eng" | "auto";
-export interface SettingsState {
-  volume: number;
-  playbackSpeed: number;
-  customPlayback: number;
-  allowCaptions: boolean;
-  captionPosition: {
-    x: number;
-    y: number;
-  };
-  captionLang: CaptionLangType;
-  captionFontFamily: string;
-  captionFontSize: number;
-  captionFontColor: string;
-  captionFontOpacity: number;
-  captionBGColor: string;
-  captionBGOpacity: number;
-  captionWindowColor: string;
-  captionWindowOpacity: number;
-  captionCharacterEdgeStyle: string;
-  selectedLanguageCode?: string;
-  globalMutedPreference: boolean;
-  preferredQuality?: number;
-  preferredAudioLanguage?: string;
-  preferredSubtitleLanguage?: string;
-}

package/dist/store/settings/validation.d.ts

@@ -1,7 +0,0 @@
-import { SettingsState } from "./types.js";
-/**
- * Validate and parse settings, returning defaults for invalid values
- * @param parsed - Raw settings object (e.g., from localStorage)
- * @returns Validated settings with defaults applied for invalid values
- */
-export declare const validateSettings: (parsed: unknown) => SettingsState;