@applicaster/zapp-react-native-utils 15.1.11-alpha.2710844646 → 15.1.11-alpha.5011222544

package/actionsExecutor/ActionExecutor.ts

@@ -12,7 +12,7 @@ const { log_error, log_debug, log_info } = createLogger({
   category: "General",
 });
 
-export class ActionExecutor {
+class ActionExecutor {
   private registeredActions: Record<string, ActionHandler> = {};
 
   // TODO: Remove context
@@ -101,8 +101,7 @@ export class ActionExecutor {
 
   registerAction = <TOptions = Record<string, any>>(
     type: string,
-    handler: ActionHandler<TOptions>,
-    stateResolver?: (entry?: ZappEntry) => any
+    handler: ActionHandler<TOptions>
   ) => {
     if (this.registeredActions[type]) {
       log_error(`registerAction: action type: ${type} already registered`);
@@ -113,48 +112,11 @@ export class ActionExecutor {
     this.registeredActions[type] = handler;
     log_debug(`registerAction: action type: ${type} registered`);
 
-    let unregisterState = () => {};
-
-    if (stateResolver) {
-      unregisterState = this.registerActionState(type, stateResolver);
-    }
-
     return () => {
       this.unregisterAction(type);
-      unregisterState();
       log_debug(`registerAction: action type: ${type} un-registered`);
     };
   };
-
-  private actionStates: Record<string, (entry?: ZappEntry) => any> = {};
-
-  registerActionState = (
-    type: string,
-    stateResolver: (entry?: ZappEntry) => any
-  ) => {
-    if (this.actionStates[type]) {
-      log_error(
-        `registerActionState: action type state: ${type} already registered`
-      );
-
-      return () => {};
-    }
-
-    this.actionStates[type] = stateResolver;
-    log_debug(`registerActionState: action type state: ${type} registered`);
-
-    return () => {
-      delete this.actionStates[type];
-
-      log_debug(
-        `registerActionState: action type state: ${type} un-registered`
-      );
-    };
-  };
-
-  getActionState = (type: string, entry?: ZappEntry) => {
-    return this.actionStates[type]?.(entry);
-  };
 }
 
 export const actionExecutor = new ActionExecutor();

package/actionsExecutor/ActionExecutorContext.tsx

@@ -18,12 +18,12 @@ import { createLogger } from "../logger";
 import {
   appRestartAction,
   confirmDialogAction,
+  createGoBackAction,
+  createGoHomeAction,
   createNavigateToScreenAction,
-  dismissBottomSheetAction,
   localStorageRemoveAction,
   localStorageSetAction,
   localStorageToggleFlagAction,
-  openBottomSheetAction,
   refreshComponentAction,
   screenSetVariableAction,
   screenToggleFlagAction,
@@ -35,8 +35,6 @@ import {
   showToastAction,
 } from "./actions";
 
-import { ACTION_TYPES } from "./consts";
-
 export const { log_error, log_info, log_debug } = createLogger({
   subsystem: "ActionExecutorContext",
   category: "General",
@@ -45,15 +43,9 @@ export const { log_error, log_info, log_debug } = createLogger({
 export type ActionExecutorContextType = {
   registerAction: <TOptions = Record<string, any>>(
     type: string,
-    handler: ActionHandler<TOptions>,
-    stateResolver?: (entry?: ZappEntry) => any
+    handler: ActionHandler<TOptions>
   ) => void;
   unregisterAction: (type: string) => void;
-  registerActionState: (
-    type: string,
-    stateResolver: (entry?: ZappEntry) => any
-  ) => () => void;
-  getActionState: (type: string, entry?: ZappEntry) => any;
   handleAction: (
     action: ActionType,
     context?: ActionExecutionContext
@@ -73,76 +65,34 @@ type Props = {
 };
 
 const prepareDefaultActions = (actionExecutor) => {
-  actionExecutor.registerAction(
-    ACTION_TYPES.LOCAL_STORAGE_SET,
-    localStorageSetAction
-  );
-
-  actionExecutor.registerAction(
-    ACTION_TYPES.SESSION_STORAGE_SET,
-    sessionStorageSetAction
-  );
-
-  actionExecutor.registerAction(
-    ACTION_TYPES.LOCAL_STORAGE_REMOVE,
-    localStorageRemoveAction
-  );
+  actionExecutor.registerAction("localStorageSet", localStorageSetAction);
+  actionExecutor.registerAction("sessionStorageSet", sessionStorageSetAction);
+  actionExecutor.registerAction("localStorageRemove", localStorageRemoveAction);
 
   actionExecutor.registerAction(
-    ACTION_TYPES.SESSION_STORAGE_REMOVE,
+    "sessionStorageRemove",
     sessionStorageRemoveAction
   );
 
-  actionExecutor.registerAction(
-    ACTION_TYPES.REFRESH_COMPONENT,
-    refreshComponentAction
-  );
-
-  actionExecutor.registerAction(ACTION_TYPES.SWITCH_LAYOUT, switchLayoutAction);
-
-  actionExecutor.registerAction(ACTION_TYPES.APP_RESTART, appRestartAction);
-
-  actionExecutor.registerAction(
-    ACTION_TYPES.CONFIRM_DIALOG,
-    confirmDialogAction
-  );
-
-  actionExecutor.registerAction(
-    ACTION_TYPES.SEND_CLOUD_EVENT,
-    sendCloudEventAction
-  );
+  actionExecutor.registerAction("refreshComponent", refreshComponentAction);
+  actionExecutor.registerAction("switchLayout", switchLayoutAction);
+  actionExecutor.registerAction("appRestart", appRestartAction);
+  actionExecutor.registerAction("confirmDialog", confirmDialogAction);
+  actionExecutor.registerAction("sendCloudEvent", sendCloudEventAction);
 
   actionExecutor.registerAction(
-    ACTION_TYPES.SESSION_STORAGE_TOGGLE_FLAG,
+    "sessionStorageToggleFlag",
     sessionStorageToggleFlagAction
   );
 
   actionExecutor.registerAction(
-    ACTION_TYPES.LOCAL_STORAGE_TOGGLE_FLAG,
+    "localStorageToggleFlag",
     localStorageToggleFlagAction
   );
 
-  actionExecutor.registerAction(
-    ACTION_TYPES.SCREEN_SET_VARIABLE,
-    screenSetVariableAction
-  );
-
-  actionExecutor.registerAction(
-    ACTION_TYPES.SCREEN_TOGGLE_FLAG,
-    screenToggleFlagAction
-  );
-
-  actionExecutor.registerAction(
-    ACTION_TYPES.OPEN_BOTTOM_SHEET,
-    openBottomSheetAction
-  );
-
-  actionExecutor.registerAction(
-    ACTION_TYPES.DISMISS_BOTTOM_SHEET,
-    dismissBottomSheetAction
-  );
-
-  actionExecutor.registerAction(ACTION_TYPES.SHOW_TOAST, showToastAction);
+  actionExecutor.registerAction("screenSetVariable", screenSetVariableAction);
+  actionExecutor.registerAction("screenToggleFlag", screenToggleFlagAction);
+  actionExecutor.registerAction("showToast", showToastAction);
 };
 
 export const ActionExecutorContext =
@@ -160,8 +110,6 @@ export function withActionExecutor(Component) {
       return {
         unregisterAction: _actionExecutor.unregisterAction,
         registerAction: _actionExecutor.registerAction,
-        registerActionState: _actionExecutor.registerActionState,
-        getActionState: _actionExecutor.getActionState,
         handleAction: _actionExecutor.handleAction,
         handleActions: _actionExecutor.handleActions,
         handleEntryActions: _actionExecutor.handleEntryActions,
@@ -184,11 +132,25 @@ export function withActionExecutor(Component) {
 
     useEffect(() => {
       return _actionExecutor.registerAction(
-        ACTION_TYPES.NAVIGATE_TO_SCREEN,
+        "navigateToScreen",
         createNavigateToScreenAction(navigator, rivers, contentTypes)
       );
     }, [navigator, rivers, contentTypes]);
 
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        "goBack",
+        createGoBackAction(navigator)
+      );
+    }, [navigator]);
+
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        "goHome",
+        createGoHomeAction(navigator)
+      );
+    }, [navigator]);
+
     return (
       <ActionExecutorContext.Provider value={handlers}>
         <Component {...props} />

package/actionsExecutor/actions/__tests__/goBack.test.ts

@@ -0,0 +1,62 @@
+import { createGoBackAction } from "../goBack";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator(canGoBack = true) {
+  return {
+    goBack: jest.fn(),
+    canGoBack: jest.fn().mockReturnValue(canGoBack),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goBack", () => {
+  it("goes back with fallbackToHome enabled when no options are provided", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoBackAction(navigator)({ type: "goBack" });
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("forwards backToTop", async () => {
+    const navigator = createNavigator();
+
+    const action = {
+      type: "goBack",
+      options: { backToTop: true },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, true);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("goes back without falling back to home when the stack allows it", async () => {
+    const navigator = createNavigator(true);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(false, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("does nothing when there is nothing to go back to and fallbackToHome is off", async () => {
+    const navigator = createNavigator(false);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).not.toHaveBeenCalled();
+    expect(result).toBe(ActionResult.Error);
+  });
+});

package/actionsExecutor/actions/__tests__/goHome.test.ts

@@ -0,0 +1,19 @@
+import { createGoHomeAction } from "../goHome";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator() {
+  return {
+    goHome: jest.fn(),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goHome", () => {
+  it("navigates to the home screen", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoHomeAction(navigator)({ type: "goHome" });
+
+    expect(navigator.goHome).toHaveBeenCalledWith();
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/goBack.ts

@@ -0,0 +1,60 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/**
+ * Options for the goBack action.
+ */
+export interface GoBackOptions {
+  /**
+   * Navigate to the home screen when there is no screen to go back to.
+   * Defaults to true.
+   */
+  fallbackToHome?: boolean;
+
+  /**
+   * Go back to the first screen of the stack instead of the previous one.
+   * Defaults to false.
+   */
+  backToTop?: boolean;
+}
+
+/**
+ * Creates a go back action handler with the provided dependencies.
+ * This factory pattern allows the action to access navigation state at runtime.
+ *
+ * @param navigator - The app navigator performing the back navigation
+ * @returns An action handler that navigates back
+ */
+export function createGoBackAction(
+  navigator: QuickBrickAppNavigator
+): ActionHandler<GoBackOptions> {
+  return async function goBackAction(action): Promise<ActionResult> {
+    const fallbackToHome = action.options?.fallbackToHome ?? true;
+    const backToTop = action.options?.backToTop ?? false;
+
+    // With fallbackToHome on, the navigator goes home on an empty stack by
+    // itself. The guard only matters when the caller opted out of that.
+    if (!fallbackToHome && !navigator.canGoBack()) {
+      log_info(
+        "goBack: no screen to go back to and fallbackToHome is disabled, ignoring"
+      );
+
+      return ActionResult.Error;
+    }
+
+    log_info(
+      `goBack: navigating back, fallbackToHome: ${fallbackToHome}, backToTop: ${backToTop}`
+    );
+
+    navigator.goBack(fallbackToHome, false, backToTop);
+
+    return ActionResult.Success;
+  };
+}

package/actionsExecutor/actions/goHome.ts

@@ -0,0 +1,31 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/**
+ * Creates a go home action handler with the provided dependencies.
+ * This factory pattern allows the action to access navigation state at runtime.
+ *
+ * The navigator's `initialLaunch` flag is intentionally not exposed: it selects
+ * the offline home river during app bootstrap and is not a per-action choice.
+ *
+ * @param navigator - The app navigator performing the navigation
+ * @returns An action handler that navigates to the home screen
+ */
+export function createGoHomeAction(
+  navigator: QuickBrickAppNavigator
+): ActionHandler {
+  return async function goHomeAction(): Promise<ActionResult> {
+    log_info("goHome: navigating to the home screen");
+
+    navigator.goHome();
+
+    return ActionResult.Success;
+  };
+}

package/actionsExecutor/actions/index.ts

@@ -27,8 +27,8 @@ export { screenToggleFlagAction } from "./screenToggleFlag";
 
 export { createNavigateToScreenAction } from "./navigateToScreen";
 
-export { showToastAction } from "./showToast";
+export { createGoBackAction } from "./goBack";
 
-export { openBottomSheetAction } from "./openBottomSheet";
+export { createGoHomeAction } from "./goHome";
 
-export { dismissBottomSheetAction } from "./dismissBottomSheet";
+export { showToastAction } from "./showToast";

package/actionsExecutor/actions/refreshComponent.ts

@@ -82,12 +82,6 @@ export const refreshComponentAction: ActionHandler = async (
       }) || source;
   }
 
-  if (!dataSource) {
-    log_info("handleAction: refreshComponent skipped: no dataSource found");
-
-    return ActionResult.Success;
-  }
-
   log_info(`handleAction: refreshComponent for dataSource:${dataSource}`, {
     source,
     inflatedUrl: dataSource,

package/actionsExecutor/actions/sendCloudEvent.ts

@@ -62,15 +62,10 @@ export const sendCloudEventAction: ActionHandler<
       subject: options.subject || String((entry as ZappEntry)?.id || ""),
     });
 
-    log_info("handleAction: sending sendCloudEvent to URL", {
-      url: options.url,
-      cloudEvent,
-    });
+    log_info("handleAction: sendCloudEvent event", { cloudEvent });
 
     const { error, code } = await sendCloudEvent(cloudEvent, options.url);
 
-    log_info("handleAction: sendCloudEvent result", { code, error });
-
     if (error) {
       log_error("sendCloudEvent: error sending cloud event", { error });
 

package/actionsExecutor/consts.ts

@@ -2,26 +2,3 @@ export const TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT =
   "action.localStorageToggleFlag.maxItemsReached";
 
 export const ACTION_EXECUTOR_EVENT_SOURCE = "ActionExecutor";
-
-export const ACTION_TYPES = {
-  OPEN_BOTTOM_SHEET: "openBottomSheet",
-  DISMISS_BOTTOM_SHEET: "dismissBottomSheet",
-  PRESENT_SUB_MENU: "presentSubMenu",
-  SEND_CLOUD_EVENT: "sendCloudEvent",
-  NAVIGATE_TO_SCREEN: "navigateToScreen",
-  SHOW_TOAST: "showToast",
-  LOCAL_STORAGE_SET: "localStorageSet",
-  LOCAL_STORAGE_REMOVE: "localStorageRemove",
-  LOCAL_STORAGE_TOGGLE_FLAG: "localStorageToggleFlag",
-  SESSION_STORAGE_SET: "sessionStorageSet",
-  SESSION_STORAGE_REMOVE: "sessionStorageRemove",
-  SESSION_STORAGE_TOGGLE_FLAG: "sessionStorageToggleFlag",
-  REFRESH_COMPONENT: "refreshComponent",
-  SWITCH_LAYOUT: "switchLayout",
-  APP_RESTART: "appRestart",
-  CONFIRM_DIALOG: "confirmDialog",
-  SCREEN_SET_VARIABLE: "screenSetVariable",
-  SCREEN_TOGGLE_FLAG: "screenToggleFlag",
-} as const;
-
-export type KnownActionType = (typeof ACTION_TYPES)[keyof typeof ACTION_TYPES];

package/actionsExecutor/types.ts

@@ -31,7 +31,7 @@ export interface ActionExecutionContext {
   /** Callback function for action completion */
   callback?: (result: { success: boolean; error: any; abort: boolean }) => void;
 
-  screenState?: Record<any, any>;
+  screenState: Record<any, any>;
 }
 
 /**

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,
@@ -252,10 +252,7 @@ export class OverlaysObserver {
         return;
       }
 
-      const playNextFeedUrl: string = await retrieveFeedUrl(
-        this.entry,
-        plugins
-      );
+      const playNextFeedUrl: string = retrieveFeedUrl(this.entry);
 
       if (!playNextFeedUrl || typeof playNextFeedUrl !== "string") {
         log_debug(

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

@@ -1,66 +1,13 @@
-const mockGetUpcomingQueue = jest.fn();
-
-jest.mock("../getUpcomingQueue", () => ({
-  getUpcomingQueue: (...args: unknown[]) => mockGetUpcomingQueue(...args),
-}));
-
 import { retrieveFeedUrl, retrievePlayPreviousFeedUrl } from "../utils";
 
 const entryWith = (extensions: Record<string, unknown>): ZappEntry =>
   ({ id: "1", type: { value: "video" }, extensions }) as ZappEntry;
 
-const queuePlugin = { identifier: "queue-action" } as ZappPlugin;
-
 describe("playlist feed url accessors", () => {
-  beforeEach(() => {
-    mockGetUpcomingQueue.mockReset();
-  });
-
-  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 a queue play-next url when upcoming items exist", async () => {
-    mockGetUpcomingQueue.mockResolvedValue([{ id: "next-item" }]);
-
-    const entry = entryWith({
-      play_next_feed_url: "https://feeds/next.json",
-      queueItemId: "queue-1",
-    });
-
-    await expect(retrieveFeedUrl(entry, [queuePlugin])).resolves.toBe(
-      "pipesv2://queue-action/play-next?queueItemId=queue-1"
-    );
-  });
-
-  it("falls back to the next feed url when the upcoming queue is empty", async () => {
-    mockGetUpcomingQueue.mockResolvedValue([]);
-
-    const entry = entryWith({ play_next_feed_url: "https://feeds/next.json" });
-
-    await expect(retrieveFeedUrl(entry, [queuePlugin])).resolves.toBe(
-      "https://feeds/next.json"
-    );
-  });
-
-  it("falls back to the next feed url when QueueManager cannot be resolved", async () => {
-    mockGetUpcomingQueue.mockRejectedValue(new Error("not available"));
-
+  it("returns the next feed url when present", () => {
     const entry = entryWith({ play_next_feed_url: "https://feeds/next.json" });
 
-    await expect(retrieveFeedUrl(entry, [queuePlugin])).resolves.toBe(
-      "https://feeds/next.json"
-    );
+    expect(retrieveFeedUrl(entry)).toBe("https://feeds/next.json");
   });
 
   it("returns the previous feed url when present", () => {

package/appUtils/playerManager/OverlayObserver/utils.ts

@@ -3,13 +3,10 @@ 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");
 
@@ -43,58 +40,14 @@ export const parseTimeToSeconds = (timeStr: string): number => {
   }
 };
 
-/**
- * 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 retrieveFeedUrl = (entry: ZappEntry) =>
+  entry?.extensions?.play_next_feed_url;
 
 export const retrievePlayPreviousFeedUrl = (entry: ZappEntry) =>
   entry?.extensions?.play_previous_feed_url;
 
 export const retrieveOverlayDuration = (plugin) =>
-  toNumberWithDefault(15, plugin?.configuration?.overlay_duration);
+  toNumberWithDefault(plugin?.configuration?.overlay_duration, 15);
 
 export const retrieveOverlayTriggerOffset = (item: ZappEntry) => {
   return item && item.extensions && item.extensions.overlay_timestamp
@@ -200,3 +153,19 @@ 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;
+};