@xhub-short/core 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/index.js

@@ -54,8 +54,9 @@ var createInitialState = () => ({
   lastFetchTime: null
 });
 var _FeedManager = class _FeedManager {
-  constructor(dataSource, config = {}, storage, prefetchConfig) {
+  constructor(dataSource, config = {}, storage, prefetchConfig, logger) {
     this.dataSource = dataSource;
+    this.logger = logger;
     /** Abort controller for cancelling in-flight requests */
     this.abortController = null;
     /**
@@ -68,6 +69,11 @@ var _FeedManager = class _FeedManager {
      * Used for garbage collection
      */
     this.accessOrder = /* @__PURE__ */ new Map();
+    /**
+     * Track videos that have already triggered predictive preload
+     * to avoid duplicate requests.
+     */
+    this.preloadedVideoIds = /* @__PURE__ */ new Set();
     this.config = { ...DEFAULT_FEED_CONFIG, ...config };
     this.prefetchConfig = { ...DEFAULT_PREFETCH_CACHE_CONFIG, ...prefetchConfig };
     this.storage = storage ?? null;
@@ -112,6 +118,25 @@ var _FeedManager = class _FeedManager {
   // ═══════════════════════════════════════════════════════════════
   // PUBLIC API
   // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get current data source
+   */
+  getDataSource() {
+    return this.dataSource;
+  }
+  /**
+   * Update data source dynamically
+   * Used for switching between Recommendation and Playlist modes
+   *
+   * @param dataSource - New data source adapter
+   * @param options - Options for state transition
+   */
+  setDataSource(dataSource, options = { reset: true }) {
+    this.dataSource = dataSource;
+    if (options.reset) {
+      this.reset();
+    }
+  }
   /**
    * Load initial feed data
    *
@@ -124,14 +149,14 @@ var _FeedManager = class _FeedManager {
    * - If a request for the same cursor is already in-flight, returns the existing Promise
    * - Prevents duplicate API calls from rapid UI interactions
    */
-  async loadInitial() {
-    if (_FeedManager.globalMemoryCache) {
+  async loadInitial(options) {
+    if (!options?.replace && _FeedManager.globalMemoryCache) {
       const { items, nextCursor } = _FeedManager.globalMemoryCache;
       this.hydrateFromSnapshot(items, nextCursor, { markAsStale: false });
       _FeedManager.globalMemoryCache = null;
       return;
     }
-    const dedupeKey = "__initial__";
+    const dedupeKey = options?.replace ? "__initial_replace__" : "__initial__";
     const existingRequest = this.inFlightRequests.get(dedupeKey);
     if (existingRequest) {
       return existingRequest;
@@ -141,7 +166,7 @@ var _FeedManager = class _FeedManager {
       return;
     }
     this.store.setState({ loading: true, error: null });
-    const request = this.executeLoadInitial();
+    const request = this.executeLoadInitial(options?.replace);
     this.inFlightRequests.set(dedupeKey, request);
     try {
       await request;
@@ -152,9 +177,9 @@ var _FeedManager = class _FeedManager {
   /**
    * Internal: Execute load initial logic
    */
-  async executeLoadInitial() {
+  async executeLoadInitial(replace = false) {
     try {
-      await this.fetchWithRetry();
+      await this.fetchWithRetry(void 0, replace);
       this.updatePrefetchCache();
     } catch (error) {
       this.handleError(error, "loadInitial");
@@ -225,6 +250,33 @@ var _FeedManager = class _FeedManager {
     } catch {
     }
   }
+  /**
+   * Handle playback progress and trigger predictive preloading
+   *
+   * @param videoId - ID of the currently playing video
+   * @param progress - Current playback progress (0-1)
+   * @param governor - Resource governor to trigger preload
+   * @param threshold - Progress threshold to trigger preload (default: 0.2)
+   */
+  handlePlaybackProgress(videoId, progress, governor, threshold = 0.2) {
+    if (this.preloadedVideoIds.has(videoId)) return;
+    if (progress >= threshold) {
+      this.preloadedVideoIds.add(videoId);
+      const state = this.store.getState();
+      const currentIndex = state.displayOrder.indexOf(videoId);
+      if (currentIndex !== -1) {
+        const nextIndices = [currentIndex + 1, currentIndex + 2].filter(
+          (idx) => idx < state.displayOrder.length
+        );
+        if (nextIndices.length > 0) {
+          governor.triggerPreload(nextIndices);
+          this.logger?.debug(
+            `[FeedManager] Predictive preload triggered for indices: ${nextIndices.join(", ")}`
+          );
+        }
+      }
+    }
+  }
   /**
    * Get a video by ID
    * Also updates LRU access time for garbage collection
@@ -255,6 +307,59 @@ var _FeedManager = class _FeedManager {
       this.store.setState({ itemsById: newItemsById });
     }
   }
+  /**
+   * Replace all items in the feed (e.g. for Playlist synchronization)
+   */
+  replaceItems(items) {
+    const newItemsById = /* @__PURE__ */ new Map();
+    const newDisplayOrder = [];
+    const now = Date.now();
+    for (const item of items) {
+      newItemsById.set(item.id, item);
+      newDisplayOrder.push(item.id);
+      this.accessOrder.set(item.id, now);
+    }
+    this.store.setState({
+      itemsById: newItemsById,
+      displayOrder: newDisplayOrder,
+      cursor: null,
+      hasMore: false
+    });
+  }
+  /**
+   * Remove an item from the feed
+   *
+   * Used for:
+   * - Report: Remove reported content from feed
+   * - Not Interested: Remove content user doesn't want to see
+   *
+   * @param id - Content ID to remove
+   * @returns true if item was removed, false if not found
+   *
+   * @example
+   * ```typescript
+   * // User reports a video
+   * const wasRemoved = feedManager.removeItem(videoId);
+   * if (wasRemoved) {
+   *   // Navigate to next video
+   * }
+   * ```
+   */
+  removeItem(id) {
+    const state = this.store.getState();
+    if (!state.itemsById.has(id)) {
+      return false;
+    }
+    const newItemsById = new Map(state.itemsById);
+    newItemsById.delete(id);
+    const newDisplayOrder = state.displayOrder.filter((itemId) => itemId !== id);
+    this.accessOrder.delete(id);
+    this.store.setState({
+      itemsById: newItemsById,
+      displayOrder: newDisplayOrder
+    });
+    return true;
+  }
   /**
    * Check if data is stale and needs revalidation
    */
@@ -270,6 +375,7 @@ var _FeedManager = class _FeedManager {
     this.cancelPendingRequests();
     this.inFlightRequests.clear();
     this.accessOrder.clear();
+    this.preloadedVideoIds.clear();
     this.store.setState(createInitialState());
   }
   /**
@@ -445,13 +551,17 @@ var _FeedManager = class _FeedManager {
   /**
    * Fetch with exponential backoff retry
    */
-  async fetchWithRetry(cursor) {
+  async fetchWithRetry(cursor, replace = false) {
     let lastError = null;
     for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
       try {
         this.abortController = new AbortController();
         const response = await this.dataSource.fetchFeed(cursor);
-        this.addVideos(response.items);
+        if (replace) {
+          this.replaceItems(response.items);
+        } else {
+          this.addVideos(response.items);
+        }
         this.store.setState({
           cursor: response.nextCursor,
           hasMore: response.hasMore,
@@ -811,7 +921,9 @@ var PlayerEngine = class {
       loopCount: 0,
       watchTime: 0,
       error: null,
-      ended: false
+      ended: false,
+      playbackRate: this.store.getState().playbackRate
+      // Persist speed across videos (AC 5)
     });
     this.emitEvent({ type: "videoChange", video });
     this.logger?.debug(`[PlayerEngine] Loaded video: ${video.id}`);
@@ -1653,25 +1765,7 @@ var LifecycleManager = class {
     this.store.setState({ isSaving: true });
     this.emitEvent({ type: "saveStart" });
     try {
-      const snapshot = {
-        items: data.items,
-        cursor: data.cursor,
-        focusedIndex: data.focusedIndex,
-        scrollPosition: data.scrollPosition,
-        savedAt: Date.now(),
-        version: this.config.version
-      };
-      if (this.config.restorePlaybackPosition) {
-        if (data.playbackTime !== void 0) {
-          snapshot.playbackTime = data.playbackTime;
-        }
-        if (data.currentVideoId !== void 0) {
-          snapshot.currentVideoId = data.currentVideoId;
-        }
-        if (data.restoreFrame !== void 0) {
-          snapshot.restoreFrame = data.restoreFrame;
-        }
-      }
+      const snapshot = this.createSnapshot(data);
       await this.storage.saveSnapshot(snapshot);
       const timestamp = Date.now();
       this.store.setState({
@@ -1812,6 +1906,25 @@ var LifecycleManager = class {
   isSnapshotStale(snapshot) {
     return Date.now() - snapshot.savedAt > this.config.revalidationThresholdMs;
   }
+  /**
+   * Create session snapshot from data
+   */
+  createSnapshot(data) {
+    const snapshot = {
+      items: data.items,
+      cursor: data.cursor,
+      focusedIndex: data.focusedIndex,
+      scrollPosition: data.scrollPosition,
+      savedAt: Date.now(),
+      version: this.config.version
+    };
+    if (this.config.restorePlaybackPosition) {
+      if (data.playbackTime !== void 0) snapshot.playbackTime = data.playbackTime;
+      if (data.currentVideoId !== void 0) snapshot.currentVideoId = data.currentVideoId;
+      if (data.restoreFrame !== void 0) snapshot.restoreFrame = data.restoreFrame;
+    }
+    return snapshot;
+  }
   /**
    * Emit event to all listeners
    */
@@ -2360,39 +2473,47 @@ var ResourceGovernor = class {
       newPreloadingIndices.add(index);
     }
     this.store.setState({ preloadingIndices: newPreloadingIndices });
-    const preloadPromises = indicesToPreload.map(async (index) => {
-      const videoInfo = this.videoSourceGetter?.(index);
-      if (!videoInfo) return;
-      try {
+    const maxParallel = 2;
+    const executeInBatches = async () => {
+      for (let i = 0; i < indicesToPreload.length; i += maxParallel) {
+        const batch = indicesToPreload.slice(i, i + maxParallel);
+        await Promise.allSettled(batch.map((index) => this.preloadOne(index, indicesToPreload)));
+      }
+    };
+    await executeInBatches();
+  }
+  /**
+   * Internal helper to preload a single video
+   */
+  async preloadOne(index, indicesToPreload) {
+    const videoInfo = this.videoSourceGetter?.(index);
+    if (!videoInfo) return;
+    try {
+      this.logger?.debug(`[ResourceGovernor] Preloading video at index ${index} (${videoInfo.id})`);
+      const result = await this.videoLoader?.preload(videoInfo.id, videoInfo.source, {
+        priority: indicesToPreload.indexOf(index)
+        // Lower index = higher priority
+      });
+      if (result?.status === "ready") {
         this.logger?.debug(
-          `[ResourceGovernor] Preloading video at index ${index} (${videoInfo.id})`
+          `[ResourceGovernor] Preload complete for index ${index} (${result.loadedBytes ?? 0} bytes)`
         );
-        const result = await this.videoLoader?.preload(videoInfo.id, videoInfo.source, {
-          priority: indicesToPreload.indexOf(index)
-          // Lower index = higher priority
-        });
-        if (result?.status === "ready") {
-          this.logger?.debug(
-            `[ResourceGovernor] Preload complete for index ${index} (${result.loadedBytes ?? 0} bytes)`
-          );
-        } else if (result?.status === "error") {
-          this.logger?.warn(
-            `[ResourceGovernor] Preload failed for index ${index}: ${result.error?.message}`
-          );
-        }
-      } catch (err) {
-        this.logger?.error(
-          "[ResourceGovernor] Preload error",
-          err instanceof Error ? err : new Error(String(err))
+      } else if (result?.status === "error") {
+        this.logger?.warn(
+          `[ResourceGovernor] Preload failed for index ${index}: ${result.error?.message}`
         );
-      } finally {
-        const currentState = this.store.getState();
-        const updatedPreloadingIndices = new Set(currentState.preloadingIndices);
-        updatedPreloadingIndices.delete(index);
-        this.store.setState({ preloadingIndices: updatedPreloadingIndices });
       }
-    });
-    await Promise.allSettled(preloadPromises);
+    } catch (err) {
+      this.logger?.error(
+        "[ResourceGovernor] Preload error",
+        err instanceof Error ? err : new Error(String(err))
+      );
+    } finally {
+      const currentState = this.store.getState();
+      const updatedPreloadingIndices = new Set(currentState.preloadingIndices);
+      updatedPreloadingIndices.delete(index);
+      this.store.setState({ preloadingIndices: updatedPreloadingIndices });
+    }
   }
   /**
    * Execute poster preloading for given indices
@@ -3571,4 +3692,226 @@ var CommentManager = class {
   }
 };
 
-export { CommentManager, DEFAULT_COMMENT_MANAGER_CONFIG, DEFAULT_FEED_CONFIG, DEFAULT_LIFECYCLE_CONFIG, DEFAULT_OPTIMISTIC_CONFIG, DEFAULT_PLAYER_CONFIG, DEFAULT_PREFETCH_CACHE_CONFIG, DEFAULT_PREFETCH_CONFIG, DEFAULT_RESOURCE_CONFIG, FeedManager, LifecycleManager, OptimisticManager, PlayerEngine, PlayerStatus, ResourceGovernor, calculatePrefetchIndices, calculateWindowIndices, canPause, canPlay, canSeek, computeAllocationChanges, createInitialCommentState, createInitialVideoCommentState, isActiveState, isValidTransition, mapNetworkType };
+// src/playlist/types.ts
+var DEFAULT_PLAYLIST_CONFIG = {
+  metadataWindowSize: 10
+};
+
+// src/playlist/PlaylistManager.ts
+var createInitialState6 = () => ({
+  playlist: null,
+  currentIndex: 0,
+  items: [],
+  loading: false,
+  error: null
+});
+var PlaylistManager = class {
+  constructor(dataSource, config = {}, governor) {
+    this.dataSource = dataSource;
+    this.governor = governor;
+    /**
+     * Internal cache of full metadata items.
+     * Items in store.items may be minified to save memory.
+     */
+    this.fullMetadataItems = [];
+    this.config = { ...DEFAULT_PLAYLIST_CONFIG, ...config };
+    this.store = createStore(createInitialState6);
+    if (this.governor) {
+      this.governorUnsubscribe = this.governor.addEventListener((event) => {
+        if (event.type === "focusChange") {
+          this.jumpTo(event.index);
+        }
+      });
+    }
+    this.store.subscribe((state, prevState) => {
+      if (state.currentIndex !== prevState.currentIndex || state.playlist !== prevState.playlist) {
+        this.updateMetadataWindow(state.currentIndex);
+      }
+    });
+  }
+  /**
+   * Load a playlist by ID
+   */
+  async loadPlaylist(id) {
+    if (!this.dataSource) {
+      this.store.setState({ error: new Error("No playlist data source provided") });
+      return;
+    }
+    this.store.setState({ loading: true, error: null });
+    try {
+      const playlist = await this.dataSource.fetchPlaylist(id);
+      this.setPlaylist(playlist);
+    } catch (error) {
+      this.store.setState({
+        loading: false,
+        error: error instanceof Error ? error : new Error("Failed to load playlist")
+      });
+    }
+  }
+  /**
+   * Set playlist data directly
+   */
+  setPlaylist(playlist) {
+    this.fullMetadataItems = [...playlist.items];
+    this.updateMetadataWindow(0);
+    this.store.setState({
+      playlist,
+      currentIndex: 0,
+      loading: false,
+      error: null
+    });
+  }
+  /**
+   * Navigate to next item
+   */
+  next() {
+    const { currentIndex, items } = this.store.getState();
+    if (currentIndex < items.length - 1) {
+      this.store.setState({ currentIndex: currentIndex + 1 });
+    }
+  }
+  /**
+   * Navigate to previous item
+   */
+  prev() {
+    const { currentIndex } = this.store.getState();
+    if (currentIndex > 0) {
+      this.store.setState({ currentIndex: currentIndex - 1 });
+    }
+  }
+  /**
+   * Jump to specific index
+   */
+  jumpTo(index) {
+    const { items } = this.store.getState();
+    if (index >= 0 && index < items.length) {
+      this.store.setState({ currentIndex: index });
+    }
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.fullMetadataItems = [];
+    this.store.setState(createInitialState6());
+  }
+  /**
+   * Destroy the manager
+   */
+  destroy() {
+    this.governorUnsubscribe?.();
+    this.reset();
+  }
+  /**
+   * Update the sliding window of full metadata items.
+   * Items outside the window are minified to save memory.
+   */
+  updateMetadataWindow(currentIndex) {
+    const { metadataWindowSize } = this.config;
+    const items = this.fullMetadataItems;
+    if (items.length === 0) return;
+    const halfWindow = Math.floor(metadataWindowSize / 2);
+    let start = Math.max(0, currentIndex - halfWindow);
+    const end = Math.min(items.length, start + metadataWindowSize);
+    if (end === items.length) {
+      start = Math.max(0, end - metadataWindowSize);
+    }
+    const windowedItems = items.map((item, index) => {
+      if (index >= start && index < end) {
+        return item;
+      }
+      return this.minifyItem(item);
+    });
+    this.store.setState({ items: windowedItems });
+  }
+  /**
+   * Create a minified version of a ContentItem to save memory.
+   * Keeps only essential fields for identification and basic UI.
+   */
+  minifyItem(item) {
+    return {
+      id: item.id,
+      type: item.type,
+      author: {
+        id: item.author.id,
+        name: item.author.name
+      },
+      // Essential stats for basic UI if needed
+      stats: {
+        likes: 0,
+        comments: 0,
+        shares: 0
+      },
+      isLiked: false,
+      isFollowing: false,
+      createdAt: ""
+    };
+  }
+};
+
+// src/playlist/PlaylistCollectionManager.ts
+var createInitialState7 = () => ({
+  playlists: [],
+  loading: false,
+  cursor: null,
+  hasMore: true,
+  error: null
+});
+var PlaylistCollectionManager = class {
+  constructor(dataSource) {
+    this.dataSource = dataSource;
+    this.store = createStore(createInitialState7);
+  }
+  /**
+   * Load more playlists (pagination)
+   */
+  async loadMore() {
+    const { loading, cursor, hasMore } = this.store.getState();
+    if (loading || !hasMore || !this.dataSource) return;
+    this.store.setState({ loading: true, error: null });
+    try {
+      const response = await this.dataSource.fetchPlaylistCollection(cursor || void 0);
+      this.store.setState((state) => ({
+        playlists: [...state.playlists, ...response.playlists],
+        cursor: response.nextCursor,
+        hasMore: response.hasMore,
+        loading: false
+      }));
+    } catch (error) {
+      this.store.setState({
+        loading: false,
+        error: error instanceof Error ? error : new Error("Failed to load playlist collection")
+      });
+    }
+  }
+  /**
+   * Refresh the collection (reset and re-fetch)
+   */
+  async refresh() {
+    if (!this.dataSource) return;
+    this.store.setState({ ...createInitialState7(), loading: true });
+    try {
+      const response = await this.dataSource.fetchPlaylistCollection();
+      this.store.setState({
+        playlists: response.playlists,
+        cursor: response.nextCursor,
+        hasMore: response.hasMore,
+        loading: false,
+        error: null
+      });
+    } catch (error) {
+      this.store.setState({
+        loading: false,
+        error: error instanceof Error ? error : new Error("Failed to refresh playlist collection")
+      });
+    }
+  }
+  /**
+   * Reset the store to initial state
+   */
+  reset() {
+    this.store.setState(createInitialState7());
+  }
+};
+
+export { CommentManager, DEFAULT_COMMENT_MANAGER_CONFIG, DEFAULT_FEED_CONFIG, DEFAULT_LIFECYCLE_CONFIG, DEFAULT_OPTIMISTIC_CONFIG, DEFAULT_PLAYER_CONFIG, DEFAULT_PREFETCH_CACHE_CONFIG, DEFAULT_PREFETCH_CONFIG, DEFAULT_RESOURCE_CONFIG, FeedManager, LifecycleManager, OptimisticManager, PlayerEngine, PlayerStatus, PlaylistCollectionManager, PlaylistManager, ResourceGovernor, calculatePrefetchIndices, calculateWindowIndices, canPause, canPlay, canSeek, computeAllocationChanges, createInitialCommentState, createInitialVideoCommentState, isActiveState, isValidTransition, mapNetworkType };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xhub-short/core",
   "sideEffects": false,
-  "version": "0.1.0-beta.10",
+  "version": "0.1.0-beta.12",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -21,14 +21,14 @@
   ],
   "dependencies": {
     "zustand": "^5.0.0",
-    "@xhub-short/contracts": "0.1.0-beta.10"
+    "@xhub-short/contracts": "0.1.0-beta.12"
   },
   "devDependencies": {
     "tsup": "^8.3.0",
     "typescript": "^5.7.0",
     "vitest": "^2.1.0",
-    "@xhub-short/tsconfig": "0.0.0",
-    "@xhub-short/vitest-config": "0.0.1-beta.9"
+    "@xhub-short/tsconfig": "0.0.1-beta.0",
+    "@xhub-short/vitest-config": "0.1.0-beta.11"
   },
   "scripts": {
     "build": "tsup",