@applicaster/zapp-react-native-utils 15.1.5 → 15.1.6-alpha.3988508055

package/modalState/index.ts

@@ -1,83 +1,30 @@
-import { useStore, createStore } from "zustand";
-
-interface ModalState {
-  visible: boolean;
-  screen: any;
-  options: Record<string, unknown>;
-  props: Record<string, unknown>;
-}
-
-interface ModalStore {
-  modalState: ModalState;
-  setModalState: (newState: Partial<ModalState>) => void;
-  openModal: (
-    item: any,
-    options?: Record<string, unknown>,
-    props?: Record<string, unknown>
-  ) => void;
-  dismissModal: () => void;
-}
-
-const initialModalState: ModalState = {
-  visible: false,
-  screen: null,
-  options: {},
-  props: {},
-};
-
-export const modalStore = createStore<ModalStore>((set) => ({
-  modalState: initialModalState,
-  setModalState: (newState) =>
-    set((state) => ({
-      modalState: { ...state.modalState, ...newState },
-    })),
-  openModal: ({ item, options = {}, props }: OpenModalArg) =>
-    set({
-      modalState: {
-        visible: true,
-        screen: item,
-        options: {
-          animated: true,
-          animationType: "slide",
-          onShow: () => {},
-          presentationStyle: "overFullScreen",
-          transparent: true,
-          ...options,
-          onDismiss: () => set({ modalState: initialModalState }),
-          onRequestClose: () => set({ modalState: initialModalState }),
-        },
-        props,
-      },
-    }),
-  dismissModal: () => set(() => ({ modalState: initialModalState })),
-}));
-
-export const useModalStore = <T>(selector: (state: ModalStore) => T) =>
-  useStore(modalStore, selector);
-
-export const openModal = modalStore.getInitialState().openModal;
-
-export const dismissModal = modalStore.getInitialState().dismissModal;
-
-export const openBottomSheetModal = ({
-  ModalBottomSheetContent,
-  modalBottomSheetContentProps,
-  props = {},
-  options = {},
-}: OpenModalBottomSheetArgs) => {
-  openModal({
-    item: {
-      ModalBottomSheetContent,
-      modalBottomSheetContentProps,
-    },
-    props,
-    options: {
-      animationType: "none",
-      animated: false,
-      ...options,
-    },
-  });
-};
-
-export const useModalStoreState = (): ModalState =>
-  useModalStore<ModalState>((state) => state.modalState);
+export {
+  modalStore,
+  useModalStore,
+  openModal,
+  dismissModal,
+  openBottomSheetModal,
+  useModalStoreState,
+} from "./store";
+
+export type { ModalState, ModalStore } from "./store";
+
+export { modalOrchestrator } from "./ModalOrchestrator";
+
+export { ContentViewModel } from "./ContentViewModel";
+
+export type {
+  Menu,
+  MenuItem,
+  Header,
+  Content,
+  Action,
+  PresentSubMenuAction,
+  SecondaryAction,
+  SelectMode,
+  SelectionBehavior,
+} from "./types";
+
+export { isPresentSubMenuAction } from "./types";
+
+export { useBottomSheetContent } from "./useBottomSheetContent";

package/modalState/store.ts

@@ -0,0 +1,102 @@
+import { createStore, useStore } from "zustand";
+
+export interface ModalState {
+  visible: boolean;
+  screen: any;
+  options: Record<string, unknown>;
+  props: Record<string, unknown>;
+}
+
+export interface ModalStore {
+  modalState: ModalState;
+  setModalState: (newState: Partial<ModalState>) => void;
+  openModal: (
+    item: any,
+    options?: Record<string, unknown>,
+    props?: Record<string, unknown>
+  ) => void;
+  dismissModal: () => void;
+}
+
+const initialModalState: ModalState = {
+  visible: false,
+  screen: null,
+  options: {},
+  props: {},
+};
+
+export const modalStore = createStore<ModalStore>((set, get) => ({
+  modalState: initialModalState,
+  setModalState: (newState) =>
+    set((state) => ({
+      modalState: { ...state.modalState, ...newState },
+    })),
+  openModal: ({ item, options = {}, props }: OpenModalArg) => {
+    const resetStore = () => set({ modalState: initialModalState });
+    const { onDismiss, onRequestClose, ...restOptions } = options as any;
+
+    set({
+      modalState: {
+        visible: true,
+        screen: item,
+        options: {
+          animated: true,
+          animationType: "slide",
+          onShow: () => {},
+          presentationStyle: "overFullScreen",
+          transparent: true,
+          ...restOptions,
+          // Compose caller-provided callbacks with the store reset so both run
+          onDismiss: () => {
+            resetStore();
+            onDismiss?.();
+          },
+          onRequestClose: () => {
+            resetStore();
+            onRequestClose?.();
+          },
+        },
+        props,
+      },
+    });
+  },
+  dismissModal: () => {
+    const onDismiss = (get().modalState?.options as any)?.onDismiss;
+
+    if (typeof onDismiss === "function") {
+      onDismiss();
+    } else {
+      set({ modalState: initialModalState });
+    }
+  },
+}));
+
+export const useModalStore = <T>(selector: (state: ModalStore) => T) =>
+  useStore(modalStore, selector);
+
+export const openModal = modalStore.getInitialState().openModal;
+
+export const dismissModal = modalStore.getInitialState().dismissModal;
+
+export const openBottomSheetModal = ({
+  ModalBottomSheetContent,
+  modalBottomSheetContentProps,
+  props = {},
+  options = {},
+}: OpenModalBottomSheetArgs) => {
+  openModal({
+    item: {
+      ModalBottomSheetContent,
+      modalBottomSheetContentProps,
+    },
+    props,
+    options: {
+      animationType: "none",
+      animated: false,
+      ...options,
+    },
+  });
+};
+
+export const useModalStoreState = (): ModalState =>
+  useModalStore<ModalState>((state) => state.modalState);

package/modalState/types.ts

@@ -0,0 +1,110 @@
+export interface Header {
+  title: string;
+  subtitle?: string;
+  icon?: string;
+}
+
+export interface Action {
+  type: string;
+  payload?: any;
+  options?: any;
+}
+
+// Represented as 3 dots icon on top menu (opens new second level menu on desktop
+// or a new bottom sheet on mobile)
+export interface PresentSubMenuAction extends Action {
+  menu: Menu;
+}
+
+export interface SecondaryAction {
+  action: Action | PresentSubMenuAction;
+  icon?: string;
+}
+
+/**
+ * A group of actions attached to an entry, keyed by a button alias
+ * (e.g. "remove_item", "reorder_item"). Injected by the feed decorator and
+ * dispatched by the remote EditableCollection when an operation runs.
+ */
+export interface EntryActionGroup {
+  button?: { alias?: string };
+  actions?: Action[];
+}
+
+export interface MenuItem {
+  id?: string;
+  title: string;
+  summary?: string;
+  icon?: string;
+  isSelected?: boolean;
+  // When item represents an audio item, clicking on it will start playback
+  // and secondary action will allow to add it to queue or playlist
+  action?: Action | PresentSubMenuAction;
+  secondaryAction?: SecondaryAction;
+  submenu?: MenuItem[]; // todo: not needed. Must be replaced with PresentSubMenuAction
+  trailingButton?: any;
+  entryActions?: EntryActionGroup[];
+}
+
+export type SelectMode = "single" | "multi" | "none";
+
+export interface SelectionBehavior {
+  selectMode?: SelectMode;
+  currentSelection?: string[];
+  selector?: string;
+}
+
+/**
+ * Operations that act on a specific item in the collection.
+ * Their action payloads are looked up on the item's entryActions (e.g. "remove_item", "reorder_item").
+ */
+export type ItemScopedOperation = "remove" | "reorder";
+
+/**
+ * Operations that act on the collection as a whole.
+ * Their action payloads are looked up on dynamicCollection.events (e.g. events.add, events.clearAll, events.delete).
+ */
+export type CollectionScopedOperation = "add" | "clearAll" | "delete";
+
+/**
+ * UI display or behavior flags that do not require action payloads.
+ */
+export type UIOperation = "nowPlaying";
+
+export type Operation =
+  | ItemScopedOperation
+  | CollectionScopedOperation
+  | UIOperation;
+
+export interface DynamicCollectionOptions {
+  operations: Operation[];
+  postUrl?: string;
+  provider?: string;
+  /**
+   * Action handlers for CollectionScopedOperations (e.g. "add", "clearAll", "delete").
+   */
+  events?: Record<CollectionScopedOperation | string, Action[]>;
+}
+
+export interface Content {
+  title: string;
+  stickyTitle?: boolean;
+  items: MenuItem[];
+  itemsUrl?: string;
+  action?: Action;
+  role?: string;
+  behavior?: SelectionBehavior;
+  dynamicCollection?: DynamicCollectionOptions;
+}
+
+export interface Menu {
+  header?: Header;
+  content: Content;
+  closeButton?: boolean;
+}
+
+export function isPresentSubMenuAction(
+  action: any
+): action is PresentSubMenuAction {
+  return !!action && typeof action === "object" && "menu" in action;
+}

package/modalState/useBottomSheetContent.ts

@@ -0,0 +1,98 @@
+import React, { useState, useEffect } from "react";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+import {
+  isPresentSubMenuAction,
+  MenuItem,
+  modalOrchestrator,
+} from "./ModalOrchestrator";
+
+import { ContentViewModel } from "./ContentViewModel";
+import type { SelectionBehavior } from "./types";
+import type { EditableCollection } from "./EditableCollection";
+
+type Props = {
+  viewModel?: ContentViewModel | null;
+  onPress: (item: MenuItem) => void | Promise<void>;
+};
+
+type Return = {
+  items: MenuItem[];
+  isLoading: boolean;
+  error?: Error | string;
+  showCentralLoading: boolean; // isLoading && items.length === 0
+  canGoBack: boolean; // modalOrchestrator.canGoBack
+  handleItemPress: (item: MenuItem) => Promise<void>;
+  goBackOrClose: () => void; // canGoBack ? back() : close()
+  close: () => void; // modalOrchestrator.close()
+  role?: string;
+  behavior?: SelectionBehavior;
+  editableCollection?: EditableCollection | null;
+};
+
+export const useBottomSheetContent = (props: Props): Return => {
+  const { onPress, viewModel } = props;
+
+  const [state, setState] = useState(viewModel?.getState());
+
+  const [editableItems, setEditableItems] = useState<MenuItem[]>([]);
+
+  // Subscribe to the viewModel state changes
+  useEffect(() => {
+    return viewModel?.subscribe((nextState) => {
+      setState(nextState);
+    });
+  }, [viewModel]);
+
+  // Subscribe to editable collection items
+  useEffect(() => {
+    if (viewModel?.editableCollection) {
+      const subscription =
+        viewModel.editableCollection.items$.subscribe(setEditableItems);
+
+      return () => subscription.unsubscribe();
+    }
+  }, [viewModel?.editableCollection]);
+
+  /**
+   * Handles an item press:
+   * - Delegates to the parent onPress (which runs the action and awaits it).
+   * - If the item was a leaf action (not a submenu), triggers viewModel.refetch()
+   *   so that checkmarks (isSelected) reflect the updated server state.
+   */
+  const handleItemPress = async (item: MenuItem) => {
+    const isSubMenu =
+      (item.submenu && item.submenu.length > 0) ||
+      (item.action && isPresentSubMenuAction(item.action));
+
+    await onPress(item);
+
+    if (!isSubMenu) {
+      await viewModel?.refetch();
+    }
+  };
+
+  const goBackOrClose = React.useCallback(() => {
+    if (modalOrchestrator.canGoBack) {
+      modalOrchestrator.back();
+    } else {
+      modalOrchestrator.close();
+    }
+  }, [modalOrchestrator.canGoBack]);
+
+  return {
+    items: viewModel?.editableCollection ? editableItems : state?.items,
+    isLoading: toBooleanWithDefaultFalse(state?.isLoading),
+    error: state?.error,
+    showCentralLoading: toBooleanWithDefaultFalse(
+      state?.isLoading && state?.items.length === 0
+    ),
+    canGoBack: modalOrchestrator.canGoBack,
+    handleItemPress,
+    goBackOrClose,
+    close: () => modalOrchestrator.close(),
+    role: state?.role,
+    behavior: state?.behavior,
+    editableCollection: viewModel?.editableCollection,
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "15.1.5",
+  "version": "15.1.6-alpha.3988508055",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "15.1.5",
+    "@applicaster/applicaster-types": "15.1.6-alpha.3988508055",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/reactHooks/actions/index.ts

@@ -1,8 +1,12 @@
 /// <reference types="@applicaster/applicaster-types" />
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { Context, useContext, useState } from "react";
+import { Context, useCallback, useContext, useEffect, useState } from "react";
 import { ActionsContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ActionsContext";
 
+import {
+  observeEntryState,
+  RegisteredActionValue,
+} from "../../uiActionsRegistrator";
 import { reactHooksLogger } from "../logger";
 
 const logger = reactHooksLogger.addSubsystem("actions");
@@ -46,3 +50,49 @@ export function useActions<T = unknown>(plugId: string): any {
 
   return context;
 }
+
+export type UseEntryActionState = {
+  state: CellActionEntryState | undefined;
+  invokeAction: (options?: InvokeArgsOptions) => void;
+};
+
+/**
+ * Subscribes a component to a single action's state for a given `entry`.
+ *
+ * It observes state changes reactively via `observeEntryState` (which is backed
+ * by the action's `addListener`), seeds the initial value synchronously from
+ * `initialEntryState`, and returns a memoized `invokeAction` that forwards
+ * optimistic `updateState` updates back into local state.
+ *
+ * This is the single, unified way to drive an action button - it works the same
+ * for registry actions, legacy context-provider actions and entry actions.
+ */
+export function useEntryActionState(
+  action: RegisteredActionValue | undefined,
+  entry: ZappEntry | ZappFeed
+): UseEntryActionState {
+  const [state, setState] = useState<CellActionEntryState | undefined>(() =>
+    action?.initialEntryState?.(entry)
+  );
+
+  const entryId = (entry as ZappEntry)?.id;
+
+  useEffect(() => {
+    if (!action) return undefined;
+
+    const subscription = observeEntryState(action, entry).subscribe(setState);
+
+    return () => subscription.unsubscribe();
+    // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+  }, [action, entryId]);
+
+  const invokeAction = useCallback(
+    (options: InvokeArgsOptions = {}) => {
+      action?.invokeAction?.(entry, { updateState: setState, ...options });
+    },
+    // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+    [action, entryId]
+  );
+
+  return { state, invokeAction };
+}

package/reactHooks/layout/index.ts

@@ -49,7 +49,7 @@ export function useStatusBarHeight() {
   });
 }
 
-const getNavbarHeight = () => {
+export const getNavbarHeight = () => {
   return isTV() ? 60 : platformSelect({ ios: 44, android: 56 });
 };