@applicaster/zapp-react-native-utils 16.0.0-rc.9 → 16.0.0-rc.90

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -3,8 +3,8 @@ import { distinctUntilChanged } from "rxjs/operators";
 import { Player } from "../player";
 import { createLogger, utilsLogger } from "../../../logger";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { findPluginByIdentifier } from "../../../pluginUtils";
 import {
-  findPluginByIdentifier,
   loadFeedEntry,
   loadFeedAndPrefetchThumbnailImage,
   parseTimeToSeconds,
@@ -19,6 +19,12 @@ export const { log_verbose, log_debug, log_info, log_error } = createLogger({
   parent: utilsLogger,
 });
 
+/**
+ * Mirrors `initial_value` for `audio_live_player_update_interval` in
+ * `defaultManifestConfigurations/player.js`.
+ */
+const DEFAULT_LIVE_CONTENT_UPDATE_INTERVAL_SECONDS = 60;
+
 type ChapterMarkerOriginal = {
   id: string;
   title: string;
@@ -40,11 +46,6 @@ export type LiveMetadataConfig = {
   updateInterval: number;
 };
 
-export type TitleSummaryEvent = {
-  title: string | number;
-  summary: string | number;
-};
-
 type ChapterMarkersObserverProps = {
   player: Player;
 };
@@ -59,24 +60,23 @@ type PlayNextConfig = {
 export type PlayNextState = PlayNextConfig & {
   triggerTime: number;
   handleUserCancelPlayNext: () => void;
+  hidePlayNext: () => void;
 };
 
 export class OverlaysObserver {
   readonly chapterSubject: BehaviorSubject<ChapterMarkerEvent>;
   private playNextSubject: BehaviorSubject<PlayNextState>;
   private liveMetadataSubject: BehaviorSubject<LiveMetadataEvent>;
-  private titleSummarySubject: BehaviorSubject<TitleSummaryEvent>;
-  private feedUrl: string;
-  private reloadData: () => void;
-  private updateTitleAndDescription: (data: any) => void;
-  private feedDataInterval: any;
+  private liveContentInterval: any;
+  private liveContentGeneration = 0;
+  private _liveEntry: ZappEntry | null = null;
   private liveMetadataUpdateInterval: any;
   private releasePlayerObserver?: () => void;
   readonly entry: ZappEntry;
   private chapterMarkerEvents: ChapterMarkerEvent[];
   readonly player: Player;
   private playNextConfig?: PlayNextConfig;
-  private isCanceledByUser = false;
+  private isPlayNextSuppressed = false;
 
   constructor({ player }: ChapterMarkersObserverProps) {
     this.chapterSubject = new BehaviorSubject(null);
@@ -85,41 +85,140 @@ export class OverlaysObserver {
     this.player = player;
     this.entry = player.getEntry();
 
-    this.titleSummarySubject = new BehaviorSubject<TitleSummaryEvent>({
-      title: this.entry?.title || "",
-      summary: this.entry?.summary || "",
-    });
-
     this.liveMetadataSubject = new BehaviorSubject<LiveMetadataEvent>(
       this.entry?.extensions?.liveMetadata || null
     );
 
     this.chapterMarkerEvents = this.prepareChapterMarkers();
     this.releasePlayerObserver = this.subscribeToPlayerEvents();
-    this.feedUrl = "";
-    this.reloadData = () => {};
-    this.updateTitleAndDescription = () => {};
-    this.feedDataInterval = null;
+    this.liveContentInterval = null;
     this.liveMetadataUpdateInterval = null;
     void this.preparePlayNext();
     void this.prepareLiveMetadata();
   }
 
-  private setupFeedDataInterval(interval: number) {
-    if (this.feedUrl && this.reloadData && this.updateTitleAndDescription) {
-      this.feedDataInterval = setInterval(() => {
-        this.reloadData();
-      }, interval * 1000);
+  /**
+   * Polls the live feed and pushes each loaded entry into the player, which
+   * re-resolves its Title/Subtitle and publishes on its content channel.
+   *
+   * Runs entirely outside React: `loadFeedEntry` builds its request through
+   * `RequestBuilder.setUrl`, which inflates URL macros with the entry and
+   * screen contexts, so no `useInflatedUrl` is needed. `prepareLiveMetadata`
+   * below already polls this way.
+   */
+  public startLiveContentUpdates() {
+    this.stopLiveContentUpdates();
+
+    if (!this.player?.isLive?.()) {
+      log_debug("startLiveContentUpdates: Player is not live. Skipping...");
+
+      return;
+    }
+
+    const feedUrl = this.getLiveContentFeedUrl();
+
+    if (!feedUrl) {
+      log_debug(
+        "startLiveContentUpdates: Entry carries no live channel feed. Skipping..."
+      );
+
+      return;
     }
+
+    const intervalSeconds = this.getLiveContentUpdateInterval();
+
+    // Clearing the interval cannot cancel a request already in flight, so each
+    // run carries the generation it started in. A response that arrives after
+    // a stop or a restart belongs to a channel that is no longer playing and
+    // is dropped, rather than publishing the previous programme's title over
+    // the current one.
+    const generation = ++this.liveContentGeneration;
+
+    const load = async () => {
+      try {
+        const entry = await loadFeedEntry(feedUrl, this.entry);
+
+        if (generation !== this.liveContentGeneration) {
+          return;
+        }
+
+        this._liveEntry = entry;
+        this.player.publishContent();
+      } catch {
+        // `loadFeedEntry` already logs the failure. Keep whatever content is
+        // currently published rather than blanking the title on a transient
+        // network error.
+      }
+    };
+
+    void load();
+
+    this.liveContentInterval = setInterval(load, intervalSeconds * 1000);
   }
 
-  public clearFeedDataInterval() {
-    if (this.feedDataInterval) {
-      clearInterval(this.feedDataInterval);
-      this.feedDataInterval = null;
+  public stopLiveContentUpdates() {
+    // Invalidates any in-flight request as well as the interval.
+    this.liveContentGeneration += 1;
+
+    if (this.liveContentInterval) {
+      clearInterval(this.liveContentInterval);
+      this.liveContentInterval = null;
     }
   }
 
+  /**
+   * The programme feed for the channel currently playing. Derived here rather
+   * than by the caller so no UI component needs to know where a live channel
+   * keeps its feed, or that the URL has to be rewritten to reach the
+   * programme ("livePage") view of it.
+   */
+  private getLiveContentFeedUrl(): string {
+    const channelSrc =
+      this.player.getEntry()?.extensions?.live?.channel_src ?? "";
+
+    return channelSrc.replace(new RegExp("subClass", "g"), "livePage");
+  }
+
+  /**
+   * Falls back to the manifest's own `initial_value` when the app ships no
+   * value: `intervalSeconds * 1000` would otherwise be `NaN`, and
+   * `setInterval` treats `NaN` as `0` - a tight loop hammering the feed.
+   */
+  private getLiveContentUpdateInterval(): number {
+    const configured =
+      this.player.getPluginConfiguration()?.audio_live_player_update_interval;
+
+    const seconds = Number(configured);
+
+    return Number.isFinite(seconds) && seconds > 0
+      ? seconds
+      : DEFAULT_LIVE_CONTENT_UPDATE_INTERVAL_SECONDS;
+  }
+
+  /**
+   * The entry most recently loaded from the live channel feed - the programme
+   * currently on air, as opposed to `player.entry`, which is the channel and
+   * stays put for the whole listening session.
+   *
+   * Read by `Player.getContent()`, which prefers it over the player's own
+   * entry. It lives here rather than on `Player` because it is live-feed
+   * state, like `liveMetadata` and play-next: a VOD or cast player never has
+   * an observer at all, so it never carries this either.
+   */
+  public get liveEntry(): ZappEntry | null {
+    return this._liveEntry;
+  }
+
+  /**
+   * Called by `Player`'s `entry` setter. The live entry is an overlay on the
+   * current entry, so its lifetime is scoped to that entry: without this, a
+   * programme from a previous channel would shadow the new one forever - the
+   * content would change but the title would not.
+   */
+  public clearLiveEntry() {
+    this._liveEntry = null;
+  }
+
   public clearLiveMetadataUpdateInterval() {
     if (this.liveMetadataUpdateInterval) {
       clearInterval(this.liveMetadataUpdateInterval);
@@ -127,25 +226,13 @@ export class OverlaysObserver {
     }
   }
 
-  public setFeedDataHandlers(
-    feedUrl: string,
-    reloadData: () => void,
-    interval: number,
-    updateTitleAndDescription: (data: any) => void
-  ) {
-    this.feedUrl = feedUrl;
-    this.reloadData = reloadData;
-    this.updateTitleAndDescription = updateTitleAndDescription;
-    this.setupFeedDataInterval(interval);
-  }
-
-  public getTitleSummaryObservable(): Observable<TitleSummaryEvent> {
-    return this.titleSummarySubject.asObservable().pipe(distinctUntilChanged());
-  }
+  hidePlayNext = () => {
+    this.isPlayNextSuppressed = true;
+    this.playNextSubject.next(null);
+  };
 
   handleUserCancelPlayNext = () => {
-    this.isCanceledByUser = true;
-    this.playNextSubject.next(null);
+    this.hidePlayNext();
   };
 
   preparePlayNext = async () => {
@@ -165,7 +252,10 @@ export class OverlaysObserver {
         return;
       }
 
-      const playNextFeedUrl: string = retrieveFeedUrl(this.entry);
+      const playNextFeedUrl: string = await retrieveFeedUrl(
+        this.entry,
+        plugins
+      );
 
       if (!playNextFeedUrl || typeof playNextFeedUrl !== "string") {
         log_debug(
@@ -270,7 +360,7 @@ export class OverlaysObserver {
 
   // TODO: Hack for video end, will be replaced with playlist prev/next in the future
   getPlayNextEntry = () =>
-    !this.isCanceledByUser ? this.playNextConfig?.entry : null;
+    !this.isPlayNextSuppressed ? this.playNextConfig?.entry : null;
 
   prepareChapterMarkers = () => {
     const chapterMarkers: ChapterMarkerOriginal[] =
@@ -353,7 +443,7 @@ export class OverlaysObserver {
     const shouldPlayNextBeVisible = currentTime > triggerTime;
 
     if (shouldPlayNextBeVisible) {
-      if (this.isCanceledByUser) {
+      if (this.isPlayNextSuppressed) {
         return;
       }
 
@@ -361,10 +451,11 @@ export class OverlaysObserver {
         ...this.playNextConfig,
         triggerTime,
         handleUserCancelPlayNext: this.handleUserCancelPlayNext,
+        hidePlayNext: this.hidePlayNext,
       });
     } else {
       this.playNextSubject.next(null);
-      this.isCanceledByUser = false;
+      this.isPlayNextSuppressed = false;
     }
   };
 
@@ -389,9 +480,8 @@ export class OverlaysObserver {
     this.chapterSubject.complete();
     this.playNextSubject.complete();
     this.liveMetadataSubject.complete();
-    this.titleSummarySubject.complete();
     this.releasePlayerObserver?.();
-    this.clearFeedDataInterval();
+    this.stopLiveContentUpdates();
     this.clearLiveMetadataUpdateInterval();
     this.releasePlayerObserver = null;
   };

package/appUtils/playerManager/OverlayObserver/__tests__/liveContent.test.ts

@@ -0,0 +1,205 @@
+import { OverlaysObserver } from "../OverlaysObserver";
+import { loadFeedEntry } from "../utils";
+
+jest.mock("../utils", () => ({
+  ...jest.requireActual("../utils"),
+  loadFeedEntry: jest.fn(),
+}));
+
+const FEED_ENTRY = { title: "Programme One" } as unknown as ZappEntry;
+
+const CHANNEL_ENTRY = {
+  title: "Channel",
+  extensions: { live: { channel_src: "https://feed.test/subClass/audio" } },
+} as unknown as ZappEntry;
+
+const makePlayer = ({
+  isLive = true,
+  entry = CHANNEL_ENTRY,
+  configuration = { audio_live_player_update_interval: 30 },
+}: {
+  isLive?: boolean;
+  entry?: ZappEntry;
+  configuration?: Record<string, any>;
+} = {}) => ({
+  isLive: () => isLive,
+  getEntry: () => entry,
+  getPluginConfiguration: () => configuration,
+  publishContent: jest.fn(),
+  addListener: jest.fn(() => () => {}),
+  removeListener: jest.fn(),
+});
+
+describe("OverlaysObserver live content", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    (loadFeedEntry as jest.Mock).mockReset();
+    (loadFeedEntry as jest.Mock).mockResolvedValue(FEED_ENTRY);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("stores the loaded programme and asks the player to republish", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observer.liveEntry).toBe(FEED_ENTRY);
+    expect(player.publishContent).toHaveBeenCalled();
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("clears the stored programme on clearLiveEntry", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    observer.clearLiveEntry();
+
+    expect(observer.liveEntry).toBeNull();
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("reloads on the configured interval", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+
+    (loadFeedEntry as jest.Mock).mockClear();
+
+    jest.advanceTimersByTime(30_000);
+
+    expect(loadFeedEntry).toHaveBeenCalledTimes(1);
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("stops polling after stopLiveContentUpdates", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+
+    observer.stopLiveContentUpdates();
+
+    (loadFeedEntry as jest.Mock).mockClear();
+
+    jest.advanceTimersByTime(90_000);
+
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+  });
+
+  it("keeps the previous content when a poll fails", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    (loadFeedEntry as jest.Mock).mockRejectedValue(new Error("network"));
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observer.liveEntry).toBeNull();
+    expect(player.publishContent).not.toHaveBeenCalled();
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("drops a response that arrives after polling was stopped", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    let resolveLoad: (entry: ZappEntry) => void;
+
+    (loadFeedEntry as jest.Mock).mockReturnValue(
+      new Promise<ZappEntry>((resolve) => {
+        resolveLoad = resolve;
+      })
+    );
+
+    observer.startLiveContentUpdates();
+    observer.stopLiveContentUpdates();
+
+    // The request was already in flight when polling stopped: clearing the
+    // interval cannot cancel it, so its result must be ignored rather than
+    // published over whatever is playing now.
+    resolveLoad(FEED_ENTRY);
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observer.liveEntry).toBeNull();
+    expect(player.publishContent).not.toHaveBeenCalled();
+  });
+
+  it("does not start polling when the entry carries no live channel feed", () => {
+    const player = makePlayer({ entry: { title: "No Feed" } as ZappEntry });
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+  });
+
+  it("does not start polling for on-demand content", () => {
+    const player = makePlayer({ isLive: false });
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+  });
+
+  it("rewrites the channel url to reach the programme feed", () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    expect(loadFeedEntry).toHaveBeenCalledWith(
+      "https://feed.test/livePage/audio",
+      expect.anything()
+    );
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("falls back to the manifest default interval when none is configured", async () => {
+    // An unset value would make `intervalSeconds * 1000` NaN, and setInterval
+    // treats NaN as 0 - a tight loop hammering the feed.
+    const player = makePlayer({ configuration: {} });
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+
+    (loadFeedEntry as jest.Mock).mockClear();
+
+    jest.advanceTimersByTime(59_000);
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+
+    jest.advanceTimersByTime(1_000);
+    expect(loadFeedEntry).toHaveBeenCalledTimes(1);
+
+    observer.stopLiveContentUpdates();
+  });
+});

package/appUtils/playerManager/OverlayObserver/__tests__/utils.test.ts

@@ -0,0 +1,49 @@
+import { retrieveFeedUrl, retrievePlayPreviousFeedUrl } from "../utils";
+
+const entryWith = (extensions: Record<string, unknown>): ZappEntry =>
+  ({ id: "1", type: { value: "video" }, extensions }) as ZappEntry;
+
+describe("playlist feed url accessors", () => {
+  it("returns the next feed url when present", async () => {
+    const entry = entryWith({ play_next_feed_url: "https://feeds/next.json" });
+
+    await expect(retrieveFeedUrl(entry, [])).resolves.toBe(
+      "https://feeds/next.json"
+    );
+  });
+
+  it("resolves to null for a missing entry", async () => {
+    await expect(
+      retrieveFeedUrl(undefined as unknown as ZappEntry, [])
+    ).resolves.toBeNull();
+  });
+
+  it("returns the previous feed url when present", () => {
+    const entry = entryWith({
+      play_previous_feed_url: "https://feeds/prev.json",
+    });
+
+    expect(retrievePlayPreviousFeedUrl(entry)).toBe("https://feeds/prev.json");
+  });
+
+  it("returns undefined when only the next url is present", () => {
+    const entry = entryWith({ play_next_feed_url: "https://feeds/next.json" });
+
+    expect(retrievePlayPreviousFeedUrl(entry)).toBeUndefined();
+  });
+
+  it("returns undefined for an entry with no extensions", () => {
+    expect(
+      retrievePlayPreviousFeedUrl({
+        id: "1",
+        type: { value: "video" },
+      } as ZappEntry)
+    ).toBeUndefined();
+  });
+
+  it("returns undefined for a missing entry", () => {
+    expect(
+      retrievePlayPreviousFeedUrl(undefined as unknown as ZappEntry)
+    ).toBeUndefined();
+  });
+});

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.android.tv.ts

@@ -0,0 +1,4 @@
+/** `queue-action` is not supported on this platform. See getUpcomingQueue.ts */
+export const getUpcomingQueue = async (
+  _plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => null;

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.ios.tv.ts

@@ -0,0 +1,4 @@
+/** `queue-action` is not supported on this platform. See getUpcomingQueue.ts */
+export const getUpcomingQueue = async (
+  _plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => null;

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.ts

@@ -0,0 +1,11 @@
+export const getUpcomingQueue = async (
+  plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => {
+  const QueueManager = (plugin as any)?.module?.QueueManager;
+
+  if (!QueueManager?.instance) {
+    return null;
+  }
+
+  return QueueManager.instance.getUpcomingQueue();
+};

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.web.ts

@@ -0,0 +1,4 @@
+/** `queue-action` is not supported on this platform. See getUpcomingQueue.ts */
+export const getUpcomingQueue = async (
+  _plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => null;

package/appUtils/playerManager/OverlayObserver/utils.ts

@@ -3,10 +3,13 @@ import {
   PipesClientResponseHelper,
   RequestBuilder,
 } from "@applicaster/zapp-pipes-v2-client";
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { log_error, log_info } from "./OverlaysObserver";
-import * as R from "ramda";
 import { toNumber, toNumberWithDefault } from "../../../numberUtils";
 
+import { findPluginByIdentifier } from "../../../pluginUtils";
+import { getUpcomingQueue } from "./getUpcomingQueue";
+
 export const parseTimeToSeconds = (timeStr: string): number => {
   const validationError = new Error("Invalid time format");
 
@@ -40,11 +43,58 @@ export const parseTimeToSeconds = (timeStr: string): number => {
   }
 };
 
-export const retrieveFeedUrl = (entry: ZappEntry) =>
-  entry?.extensions?.play_next_feed_url;
+/**
+ * HACK / TEMPORARY WORKAROUND:
+ * Resolves the play_next_feed_url dynamically for OverlaysObserver.
+ *
+ * WHY THIS IS HACKED HERE:
+ * OverlaysObserver was originally designed as a Recommendation Overlay engine (fetching static
+ * play_next_feed_url for overlay UI visuals). However, for dynamic queue & continuous audio playback,
+ * modifying feeds via `decorateFeed` at load time doesn't work (due to feed caching and mid-playback queue mutations).
+ * To avoid mutating feed payloads across the app, we temporarily intercept play_next_feed_url here
+ * at runtime to check if QueueManager has active/upcoming queue items.
+ *
+ * FUTURE ARCHITECTURE / TODO:
+ * Move queue/playlist resolution into a dedicated Player/Queue Provider module (or Handler Chain)
+ * on playerManager, decoupling Queue playback logic entirely from OverlaysObserver (which should
+ * strictly focus on recommendation visuals and chapter markers).
+ */
+export const retrieveFeedUrl = async (
+  entry: ZappEntry,
+  plugins?: ZappPlugin[]
+): Promise<string> => {
+  if (!entry) return null;
+
+  const availablePlugins = plugins || appStore.get("plugins");
+
+  const queuePlugin = findPluginByIdentifier(
+    "queue-action",
+    availablePlugins,
+    true
+  );
+
+  if (queuePlugin) {
+    try {
+      const upcomingQueue = await getUpcomingQueue(queuePlugin);
+
+      if (upcomingQueue && upcomingQueue.length > 0) {
+        const queueItemId = entry?.extensions?.queueItemId || entry?.id;
+
+        return `pipesv2://queue-action/play-next?queueItemId=${queueItemId}`;
+      }
+    } catch (e) {
+      log_error("retrieveFeedUrl: Failed to resolve QueueManager", e);
+    }
+  }
+
+  return entry?.extensions?.play_next_feed_url;
+};
+
+export const retrievePlayPreviousFeedUrl = (entry: ZappEntry) =>
+  entry?.extensions?.play_previous_feed_url;
 
 export const retrieveOverlayDuration = (plugin) =>
-  toNumberWithDefault(plugin?.configuration?.overlay_duration, 15);
+  toNumberWithDefault(15, plugin?.configuration?.overlay_duration);
 
 export const retrieveOverlayTriggerOffset = (item: ZappEntry) => {
   return item && item.extensions && item.extensions.overlay_timestamp
@@ -150,19 +200,3 @@ export const loadFeedAndPrefetchThumbnailImage = async (
 
   return playNextEntry;
 };
-
-export const findPluginByIdentifier = (
-  identifier: string,
-  plugins: ZappPlugin[]
-): ZappPlugin => {
-  if (!identifier) {
-    return undefined;
-  }
-
-  const plugin = R.compose(
-    R.find(R.propEq("identifier", identifier)),
-    R.values
-  )(plugins);
-
-  return plugin;
-};