@rixl/media-core 1.0.1 → 1.1.0

package/dist/store/feed-cache-store.js

@@ -1,165 +0,0 @@
-import { atom } from "nanostores";
-
-// src/store/feed-cache-store.ts
-const CACHE_KEY = "rixl_feed_cache";
-const CACHE_VERSION = 6;
-const MAX_CACHED_POSTS = 50;
-const feedCacheAtom = atom({
-	cachedPosts: [],
-	isLoadingFromCache: false
-});
-/**
-* Check that a value is a non-null object (narrows from unknown)
-*/
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-/**
-* Check that all common string fields are present on a post-like object
-*/
-function hasRequiredStringFields(post) {
-	return typeof post.id === "string" && typeof post.creatorId === "string" && typeof post.feedId === "string" && typeof post.description === "string" && typeof post.createdAt === "string";
-}
-/**
-* Validate a single post to ensure it has all required fields
-*/
-function isValidPost(post) {
-	if (!isObject(post)) return false;
-	if (!hasRequiredStringFields(post)) return false;
-	const isVideo = post.type === "video";
-	const isImage = post.type === "image";
-	if (!isVideo && !isImage) return false;
-	return isVideo ? post.video !== void 0 : post.image !== void 0;
-}
-/**
-* Load cached posts from localStorage.
-* If feedId is provided and doesn't match the cached feedId, cache is cleared.
-*/
-function loadFromLocalStorage(feedId) {
-	try {
-		const cached = localStorage.getItem(CACHE_KEY);
-		if (!cached) return [];
-		const data = JSON.parse(cached);
-		if (data.version !== CACHE_VERSION) {
-			localStorage.removeItem(CACHE_KEY);
-			return [];
-		}
-		if (feedId && data.feedId && data.feedId !== feedId) {
-			localStorage.removeItem(CACHE_KEY);
-			return [];
-		}
-		const validPosts = data.posts.filter((post) => {
-			if (!isValidPost(post)) {
-				console.warn("[FeedCache] Invalid post found in cache:", post);
-				return false;
-			}
-			return true;
-		});
-		if (validPosts.length !== data.posts.length) saveToLocalStorage(validPosts, feedId);
-		return validPosts;
-	} catch {
-		localStorage.removeItem(CACHE_KEY);
-		return [];
-	}
-}
-/**
-* Save posts to localStorage
-*/
-function saveToLocalStorage(posts, feedId) {
-	try {
-		const postsToCache = posts.slice(0, MAX_CACHED_POSTS);
-		const data = {
-			version: CACHE_VERSION,
-			feedId,
-			posts: postsToCache,
-			timestamp: Date.now()
-		};
-		localStorage.setItem(CACHE_KEY, JSON.stringify(data));
-	} catch (error) {
-		if (error instanceof DOMException && error.name === "QuotaExceededError") localStorage.removeItem(CACHE_KEY);
-	}
-}
-const feedCacheStore = {
-	/** The current feed ID associated with the cache */
-	currentFeedId: void 0,
-	/**
-	* Load cached posts from localStorage on app init.
-	* Clears cache if feedId changed since last session.
-	*/
-	loadCache(feedId) {
-		this.currentFeedId = feedId;
-		feedCacheAtom.set({
-			...feedCacheAtom.get(),
-			isLoadingFromCache: true
-		});
-		const cachedPosts = loadFromLocalStorage(feedId);
-		feedCacheAtom.set({
-			cachedPosts,
-			isLoadingFromCache: false
-		});
-		return cachedPosts;
-	},
-	/**
-	* Save new posts to cache (append to existing)
-	*/
-	saveNewPosts(newPosts, feedId) {
-		if (feedId !== void 0 && feedId !== this.currentFeedId) return;
-		const currentState = feedCacheAtom.get();
-		const existingIds = new Set(currentState.cachedPosts.map((p) => p.id));
-		const uniqueNewPosts = newPosts.filter((post) => !existingIds.has(post.id));
-		if (uniqueNewPosts.length === 0) return;
-		const updatedPosts = [...currentState.cachedPosts, ...uniqueNewPosts];
-		feedCacheAtom.set({
-			...currentState,
-			cachedPosts: updatedPosts
-		});
-		saveToLocalStorage(updatedPosts, this.currentFeedId);
-	},
-	/**
-	* Remove a viewed post from cache
-	*/
-	removePost(postId) {
-		const currentState = feedCacheAtom.get();
-		const filteredPosts = currentState.cachedPosts.filter((post) => post.id !== postId);
-		if (filteredPosts.length === currentState.cachedPosts.length) return;
-		feedCacheAtom.set({
-			...currentState,
-			cachedPosts: filteredPosts
-		});
-		saveToLocalStorage(filteredPosts, this.currentFeedId);
-	},
-	/**
-	* Clear all cached posts
-	*/
-	clearCache() {
-		localStorage.removeItem(CACHE_KEY);
-		feedCacheAtom.set({
-			cachedPosts: [],
-			isLoadingFromCache: false
-		});
-	},
-	/**
-	* Get cache statistics
-	*/
-	getCacheStats() {
-		try {
-			const cached = localStorage.getItem(CACHE_KEY);
-			if (!cached) return {
-				size: 0,
-				timestamp: null
-			};
-			const data = JSON.parse(cached);
-			return {
-				size: data.posts.length,
-				timestamp: data.timestamp
-			};
-		} catch {
-			return {
-				size: 0,
-				timestamp: null
-			};
-		}
-	}
-};
-
-export { feedCacheAtom, feedCacheStore };

package/dist/store/feed-interaction-store.d.ts

@@ -1,17 +0,0 @@
-import { WritableAtom } from "nanostores";
-export declare const FEED_COMPONENTS_COUNT = 5;
-export declare const FEED_TRANSITION_THRESHOLD: number;
-interface FeedInteractionStore {
-  hasInteracted: WritableAtom<boolean>;
-  whenInteracted: WritableAtom<Date>;
-  hasInitialized: WritableAtom<boolean>;
-  videosInitialized: WritableAtom<number>;
-  components: WritableAtom<number[]>;
-  originalPositions: WritableAtom<number[]>;
-  transforms: WritableAtom<number[]>;
-  setTransforms: (transforms: number[]) => void;
-}
-export declare const feedStore: FeedInteractionStore;
-export declare const setHasInteracted: () => boolean;
-export declare const initializeVideo: () => void;
-export {};

package/dist/store/feed-interaction-store.js

@@ -1,32 +0,0 @@
-import { atom } from "nanostores";
-
-// src/store/feed-interaction-store.ts
-const FEED_COMPONENTS_COUNT = 5;
-const FEED_TRANSITION_THRESHOLD = Math.floor(5 / 2);
-const feedStore = {
-	hasInteracted: atom(false),
-	whenInteracted: atom(/* @__PURE__ */ new Date(0)),
-	hasInitialized: atom(false),
-	videosInitialized: atom(5),
-	components: atom(Array.from({ length: 5 })),
-	originalPositions: atom(Array.from({ length: 5 }).map((_, i) => i)),
-	transforms: atom(Array.from({ length: 5 }).map((_, i) => i)),
-	setTransforms: (transforms) => {
-		const current = feedStore.transforms.get();
-		if (current.length === transforms.length && current.every((v, i) => v === transforms[i])) return;
-		feedStore.transforms.set(transforms);
-	}
-};
-const setHasInteracted = () => {
-	if (feedStore.hasInitialized.get()) {
-		feedStore.hasInteracted.set(true);
-		feedStore.whenInteracted.set(/* @__PURE__ */ new Date());
-	}
-	return feedStore.hasInteracted.get();
-};
-const initializeVideo = () => {
-	feedStore.videosInitialized.set(feedStore.videosInitialized.get() + 1);
-	if (feedStore.videosInitialized.get() >= 5) feedStore.hasInitialized.set(true);
-};
-
-export { FEED_COMPONENTS_COUNT, FEED_TRANSITION_THRESHOLD, feedStore, initializeVideo, setHasInteracted };

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

@@ -1,16 +0,0 @@
-import { FeedPost, FeedPostsResponse } from "../types/feed.js";
-/**
- * Get a feed post by ID, using cache if available
- * @param feedId ID of the feed
- * @param postId ID of the post to fetch
- * @returns Promise with the feed post
- */
-export declare const getFeedPost: (feedId: string, postId: string) => Promise<FeedPost>;
-/**
- * Get posts from a specific feed, with pagination
- * @param feedId ID of the feed
- * @param offset Pagination offset
- * @param limit Maximum number of items to return
- * @returns Promise with feed posts response
- */
-export declare const getFeedPosts: (feedId: string, offset?: number, limit?: number) => Promise<FeedPostsResponse>;

package/dist/store/feed-store.js

@@ -1,38 +0,0 @@
-import { fetchFeedPost, fetchFeedPosts } from "../api/feed.js";
-import { createStore } from "./generic-store.js";
-
-// src/store/feed-store.ts
-const store = createStore();
-const feedListCache = /* @__PURE__ */ new Map();
-/**
-* Get a feed post by ID, using cache if available
-* @param feedId ID of the feed
-* @param postId ID of the post to fetch
-* @returns Promise with the feed post
-*/
-const getFeedPost = async (feedId, postId) => {
-	const cacheKey = `${feedId}:${postId}`;
-	return store.get(cacheKey, () => fetchFeedPost(feedId, postId));
-};
-/**
-* Get posts from a specific feed, with pagination
-* @param feedId ID of the feed
-* @param offset Pagination offset
-* @param limit Maximum number of items to return
-* @returns Promise with feed posts response
-*/
-const getFeedPosts = async (feedId, offset = 0, limit = 10) => {
-	if (offset > 0) return fetchFeedPosts(feedId, offset, limit);
-	const cacheKey = `feed:${feedId}`;
-	const cachedPosts = feedListCache.get(cacheKey);
-	if (cachedPosts) return cachedPosts;
-	const posts = await fetchFeedPosts(feedId, offset, limit);
-	feedListCache.set(cacheKey, posts);
-	posts.posts.forEach((post) => {
-		const postKey = `${feedId}:${post.id}`;
-		store.get(postKey, () => Promise.resolve(post));
-	});
-	return posts;
-};
-
-export { getFeedPost, getFeedPosts };

package/dist/store/generic-store.js

@@ -1,24 +0,0 @@
-// src/store/generic-store.ts
-const createStore = () => {
-	const store = /* @__PURE__ */ new Map();
-	const pendingRequests = /* @__PURE__ */ new Map();
-	const get = async (id, fetcher) => {
-		const item = store.get(id);
-		if (item) return item;
-		const pendingRequest = pendingRequests.get(id);
-		if (pendingRequest) return pendingRequest;
-		const request = fetcher(id).then((apiItem) => {
-			store.set(id, apiItem);
-			pendingRequests.delete(id);
-			return apiItem;
-		}).catch((error) => {
-			pendingRequests.delete(id);
-			throw error;
-		});
-		pendingRequests.set(id, request);
-		return request;
-	};
-	return { get };
-};
-
-export { createStore };

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

@@ -1,2 +0,0 @@
-import { ImageData } from "../types/image.js";
-export declare const getImage: (imageId: string) => Promise<ImageData>;

package/dist/store/image-store.js

@@ -1,8 +0,0 @@
-import { fetchImage } from "../api/image.js";
-import { createStore } from "./generic-store.js";
-
-// src/store/image-store.ts
-const imageStore = createStore();
-const getImage = (imageId) => imageStore.get(imageId, fetchImage);
-
-export { getImage };

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

@@ -1,10 +0,0 @@
-import { UUID } from "../types/uuid.js";
-interface PlayerContainerElementStore {
-  register: (playerId: UUID, element: HTMLDivElement) => void;
-  unregister: (playerId: UUID) => void;
-  get: (playerId: UUID) => HTMLDivElement | null;
-  subscribe: (playerId: UUID, listener: () => void) => () => void;
-  clear: () => void;
-}
-export declare const playerContainerElementStore: PlayerContainerElementStore;
-export {};

package/dist/store/player-container-element-store.js

@@ -1,38 +0,0 @@
-// src/store/player-container-element-store.ts
-const state = /* @__PURE__ */ new Map();
-const listeners = /* @__PURE__ */ new Map();
-function notify(playerId) {
-	listeners.get(playerId)?.forEach((listener) => listener());
-}
-const playerContainerElementStore = {
-	register: (playerId, element) => {
-		state.set(playerId, element);
-		notify(playerId);
-	},
-	unregister: (playerId) => {
-		state.delete(playerId);
-		notify(playerId);
-	},
-	get: (playerId) => state.get(playerId) ?? null,
-	subscribe: (playerId, listener) => {
-		let playerListeners = listeners.get(playerId);
-		if (!playerListeners) {
-			playerListeners = /* @__PURE__ */ new Set();
-			listeners.set(playerId, playerListeners);
-		}
-		playerListeners.add(listener);
-		return () => {
-			const currentListeners = listeners.get(playerId);
-			if (!currentListeners) return;
-			currentListeners.delete(listener);
-			if (currentListeners.size === 0) listeners.delete(playerId);
-		};
-	},
-	clear: () => {
-		const playerIds = /* @__PURE__ */ new Set([...state.keys(), ...listeners.keys()]);
-		state.clear();
-		playerIds.forEach((playerId) => notify(playerId));
-	}
-};
-
-export { playerContainerElementStore };

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

@@ -1,53 +0,0 @@
-import { settingsStore } from "./settings/store.js";
-
-// src/store/player-global-actions.ts
-function findTrackIndexByLanguage(tracks, language) {
-	return tracks.findIndex((track) => track.language === language);
-}
-const playerGlobalActions = {
-	setGlobalMuted(muted) {
-		this.state.forEach((_atom, playerId) => {
-			if (!muted) this.setHasInteracted(playerId);
-			this.setMuted(playerId, muted);
-		});
-		settingsStore.setMuted(muted);
-	},
-	setGlobalVolume(volume) {
-		this.state.forEach((_atom, playerId) => this.setVolume(playerId, volume));
-		settingsStore.setVolume(volume);
-	},
-	setGlobalPlaybackRate(rate) {
-		this.state.forEach((_atom, playerId) => this.setPlaybackRate(playerId, rate));
-		settingsStore.setPlaybackSpeed(rate);
-	},
-	setGlobalPreferredQuality(quality) {
-		settingsStore.setPreferredQuality(quality);
-	},
-	setGlobalPreferredAudioLanguage(language) {
-		settingsStore.setPreferredAudioLanguage(language);
-		if (!language) return;
-		this.state.forEach((_atom, playerId) => {
-			const { availableAudioTracks } = this.get(playerId).get();
-			const index = findTrackIndexByLanguage(availableAudioTracks, language);
-			if (index >= 0) this.setAudioTrack(playerId, index);
-		});
-	},
-	setGlobalPreferredSubtitleLanguage(language) {
-		settingsStore.setPreferredSubtitleLanguage(language);
-		if (language === void 0) return;
-		if (language === "") {
-			this.state.forEach((_atom, playerId) => this.setSubtitleTrack(playerId, -1));
-			return;
-		}
-		this.state.forEach((_atom, playerId) => {
-			const { availableSubtitleTracks } = this.get(playerId).get();
-			const index = findTrackIndexByLanguage(availableSubtitleTracks, language);
-			if (index >= 0) this.setSubtitleTrack(playerId, index);
-		});
-	},
-	pauseAllPlayers() {
-		this.state.forEach((_atom, playerId) => this.setPaused(playerId, true));
-	}
-};
-
-export { playerGlobalActions };

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

@@ -1,10 +0,0 @@
-import { UUID } from "../types/uuid.js";
-interface PlayerMediaElementStore {
-  register: (playerId: UUID, element: HTMLVideoElement) => void;
-  unregister: (playerId: UUID) => void;
-  get: (playerId: UUID) => HTMLVideoElement | null;
-  subscribe: (playerId: UUID, listener: () => void) => () => void;
-  clear: () => void;
-}
-export declare const playerMediaElementStore: PlayerMediaElementStore;
-export {};

package/dist/store/player-media-element-store.js

@@ -1,38 +0,0 @@
-// src/store/player-media-element-store.ts
-const state = /* @__PURE__ */ new Map();
-const listeners = /* @__PURE__ */ new Map();
-function notify(playerId) {
-	listeners.get(playerId)?.forEach((listener) => listener());
-}
-const playerMediaElementStore = {
-	register: (playerId, element) => {
-		state.set(playerId, element);
-		notify(playerId);
-	},
-	unregister: (playerId) => {
-		state.delete(playerId);
-		notify(playerId);
-	},
-	get: (playerId) => state.get(playerId) ?? null,
-	subscribe: (playerId, listener) => {
-		let playerListeners = listeners.get(playerId);
-		if (!playerListeners) {
-			playerListeners = /* @__PURE__ */ new Set();
-			listeners.set(playerId, playerListeners);
-		}
-		playerListeners.add(listener);
-		return () => {
-			const currentListeners = listeners.get(playerId);
-			if (!currentListeners) return;
-			currentListeners.delete(listener);
-			if (currentListeners.size === 0) listeners.delete(playerId);
-		};
-	},
-	clear: () => {
-		const playerIds = /* @__PURE__ */ new Set([...state.keys(), ...listeners.keys()]);
-		state.clear();
-		playerIds.forEach((playerId) => notify(playerId));
-	}
-};
-
-export { playerMediaElementStore };

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

@@ -1,197 +0,0 @@
-import { clamp } from "../lib/numbers.js";
-import { clampVolume, getRestoredVolume } from "../lib/volume-utils.js";
-import { playerMediaElementStore } from "./player-media-element-store.js";
-
-// src/store/player-store-actions.ts
-const PROGRESS_EVENTS = [
-	"loadedmetadata",
-	"durationchange",
-	"timeupdate",
-	"progress",
-	"seeking",
-	"seeked",
-	"emptied"
-];
-const progressSnapshotCache = /* @__PURE__ */ new Map();
-function toSafeDuration(video) {
-	const duration = video?.duration ?? 0;
-	return Number.isFinite(duration) && duration > 0 ? duration : 0;
-}
-function toSafeCurrentTime(video, duration) {
-	if (!video || duration <= 0) return 0;
-	const currentTime = video.currentTime;
-	if (!Number.isFinite(currentTime)) return 0;
-	return clamp(currentTime, 0, duration);
-}
-function toSafeBuffered(video, duration) {
-	if (!video || duration <= 0 || video.buffered.length === 0) return 0;
-	try {
-		const bufferedEnd = video.buffered.end(video.buffered.length - 1);
-		if (!Number.isFinite(bufferedEnd)) return 0;
-		return clamp(bufferedEnd / duration, 0, 1);
-	} catch {
-		return 0;
-	}
-}
-function subscribeToProgressVideo(video, onStoreChange) {
-	if (!video) return () => {};
-	let active = true;
-	let queued = false;
-	const handleStoreChange = () => {
-		if (queued) return;
-		queued = true;
-		queueMicrotask(() => {
-			queued = false;
-			if (!active) return;
-			onStoreChange();
-		});
-	};
-	PROGRESS_EVENTS.forEach((eventName) => {
-		video.addEventListener(eventName, handleStoreChange);
-	});
-	return () => {
-		active = false;
-		PROGRESS_EVENTS.forEach((eventName) => {
-			video.removeEventListener(eventName, handleStoreChange);
-		});
-	};
-}
-/**
-* Apply the store's volume/muted to the registered media element — same
-* pattern as playMedia/pauseMedia, so frameworks never re-apply by hand.
-*/
-function applyVolumeStateToElement(id, state) {
-	const video = playerMediaElementStore.get(id);
-	if (!video) return;
-	video.volume = state.volume;
-	video.muted = state.muted;
-}
-const playerStateActions = {
-	getEffectiveMediaMuted: (player) => player.muted || player.volume === 0 || !player.hasInteracted,
-	muteMedia(id) {
-		const player = this.get(id).get();
-		this.setHasInteracted(id);
-		if (player.volume > 0) this.setPreviousVolume(id, player.volume);
-		this.setVolume(id, 0);
-		this.setMuted(id, true);
-		applyVolumeStateToElement(id, this.get(id).get());
-	},
-	unmuteMedia(id) {
-		const player = this.get(id).get();
-		const restoredVolume = getRestoredVolume(player.volume, player.previousVolume);
-		this.setHasInteracted(id);
-		if (player.volume === 0) this.setVolume(id, restoredVolume);
-		this.setMuted(id, false);
-		applyVolumeStateToElement(id, this.get(id).get());
-	},
-	toggleMediaMute(id) {
-		const player = this.get(id).get();
-		if (this.getEffectiveMediaMuted(player)) {
-			this.unmuteMedia(id);
-			return;
-		}
-		this.muteMedia(id);
-	},
-	setMediaVolume(id, volume) {
-		const player = this.get(id).get();
-		const nextVolume = clampVolume(volume);
-		this.setHasInteracted(id);
-		if (nextVolume === 0 && player.volume > 0) this.setPreviousVolume(id, player.volume);
-		this.setVolume(id, nextVolume);
-		this.setMuted(id, nextVolume === 0);
-		applyVolumeStateToElement(id, this.get(id).get());
-	},
-	async playMedia(id) {
-		const video = playerMediaElementStore.get(id);
-		if (!video) return;
-		this.setHasInteracted(id);
-		this.setEnded(id, false);
-		this.setPaused(id, false);
-		try {
-			await video.play();
-		} catch {
-			this.setPaused(id, true);
-		}
-	},
-	pauseMedia(id) {
-		const video = playerMediaElementStore.get(id);
-		if (!video) return;
-		video.pause();
-		this.setPaused(id, true);
-	},
-	async toggleMediaPlayback(id) {
-		if (this.get(id).get().paused) {
-			await this.playMedia(id);
-			return;
-		}
-		this.pauseMedia(id);
-	},
-	pauseOtherMedia(except) {
-		this.state.forEach((_player, playerId) => {
-			if (playerId === except) return;
-			const video = playerMediaElementStore.get(playerId);
-			if (video) video.pause();
-			this.setPaused(playerId, true);
-		});
-	},
-	setMediaPlaybackRate(id, playbackRate) {
-		const video = playerMediaElementStore.get(id);
-		this.setPlaybackRate(id, playbackRate);
-		if (video) video.playbackRate = this.get(id).get().playbackRate;
-	},
-	readProgressSnapshot(id) {
-		const video = playerMediaElementStore.get(id);
-		const duration = toSafeDuration(video);
-		const currentTime = toSafeCurrentTime(video, duration);
-		const nextSnapshot = {
-			currentTime,
-			duration,
-			progress: duration > 0 ? clamp(currentTime / duration, 0, 1) : 0,
-			buffered: toSafeBuffered(video, duration)
-		};
-		const cachedSnapshot = progressSnapshotCache.get(id);
-		if (cachedSnapshot && cachedSnapshot.currentTime === nextSnapshot.currentTime && cachedSnapshot.duration === nextSnapshot.duration && cachedSnapshot.progress === nextSnapshot.progress && cachedSnapshot.buffered === nextSnapshot.buffered) return cachedSnapshot;
-		progressSnapshotCache.set(id, nextSnapshot);
-		return nextSnapshot;
-	},
-	subscribeToProgress(id, onStoreChange) {
-		let currentVideo = playerMediaElementStore.get(id);
-		let unsubscribeVideo = subscribeToProgressVideo(currentVideo, onStoreChange);
-		const unsubscribeRegistry = playerMediaElementStore.subscribe(id, () => {
-			const nextVideo = playerMediaElementStore.get(id);
-			if (nextVideo === currentVideo) return;
-			unsubscribeVideo();
-			currentVideo = nextVideo;
-			unsubscribeVideo = subscribeToProgressVideo(currentVideo, onStoreChange);
-			onStoreChange();
-		});
-		return () => {
-			unsubscribeRegistry();
-			unsubscribeVideo();
-		};
-	},
-	seekProgressTo(id, seconds) {
-		const video = playerMediaElementStore.get(id);
-		if (!video) return;
-		const duration = toSafeDuration(video);
-		if (duration <= 0) {
-			video.currentTime = 0;
-			return;
-		}
-		video.currentTime = clamp(Number.isFinite(seconds) ? seconds : 0, 0, duration);
-	},
-	seekProgressBy(id, deltaSeconds) {
-		const video = playerMediaElementStore.get(id);
-		if (!video) return;
-		const duration = toSafeDuration(video);
-		if (duration <= 0) {
-			video.currentTime = 0;
-			return;
-		}
-		const delta = Number.isFinite(deltaSeconds) ? deltaSeconds : 0;
-		const currentTime = toSafeCurrentTime(video, duration);
-		video.currentTime = clamp(currentTime + delta, 0, duration);
-	}
-};
-
-export { playerStateActions };