@applicaster/zapp-react-native-utils 16.0.0-alpha.5402127570 → 16.0.0-alpha.5548956531

package/manifestUtils/fieldUtils/index.js

@@ -1,3 +1,121 @@
+const { ZAPPIFEST_FIELDS } = require("../keys");
+const { toCamelCase } = require("../_internals");
+
+const SIDES = ["top", "right", "bottom", "left"];
+
+/**
+ * Parses a CSS margin/padding shorthand string into [top, right, bottom, left].
+ *
+ * 1 value  → all four sides
+ * 2 values → top/bottom, right/left
+ * 3 values → top, right/left, bottom
+ * 4 values → top, right, bottom, left
+ *
+ * @param {string} str
+ * @returns {[number, number, number, number]}
+ */
+function parseShorthand(str) {
+  const parts = String(str).trim().split(/\s+/).map(Number);
+
+  switch (parts.length) {
+    case 1:
+      return [parts[0], parts[0], parts[0], parts[0]];
+    case 2:
+      return [parts[0], parts[1], parts[0], parts[1]];
+    case 3:
+      return [parts[0], parts[1], parts[2], parts[1]];
+    case 4:
+      return parts;
+    default:
+      throw new Error(
+        `Shorthand expects 1–4 space-separated values, got ${parts.length}: "${str}"`
+      );
+  }
+}
+
+function spacingFields(prefix, initialValues) {
+  const platforms = Object.keys(initialValues);
+
+  const parsed = Object.fromEntries(
+    platforms.map((p) => [p, parseShorthand(initialValues[p])])
+  );
+
+  return SIDES.map((side, i) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+    initialValue: Object.fromEntries(platforms.map((p) => [p, parsed[p][i]])),
+  }));
+}
+
+/**
+ * Generates four margin field descriptors (top/right/bottom/left) from a
+ * per-platform CSS shorthand string.
+ *
+ * @param {string} suffix - prefix word for generated field names, e.g. "margin"
+ * @param {Record<string, string>} initialValues - e.g. { mobile: "0 0 20", tv: "0 0 90" }
+ * @returns {object[]}
+ */
+function margin(suffix, initialValues) {
+  return spacingFields(suffix, initialValues);
+}
+
+/**
+ * Generates four padding field descriptors (top/right/bottom/left) from a
+ * per-platform CSS shorthand string.
+ *
+ * @param {string} suffix - prefix word for generated field names, e.g. "padding"
+ * @param {Record<string, string>} initialValues - e.g. { mobile: "0 20", tv: "0 124" }
+ * @returns {object[]}
+ */
+function padding(suffix, initialValues) {
+  return spacingFields(suffix, initialValues);
+}
+
+/**
+ * Returns a flat camelCase defaults object for a spacing shorthand.
+ * e.g. marginDefaults("margin", "0 0 20") → { marginTop: 0, marginRight: 0, marginBottom: 20, marginLeft: 0 }
+ *
+ * @param {string} suffix - e.g. "margin" or "padding"
+ * @param {string} shorthand - CSS-like shorthand string
+ * @returns {Record<string, number>}
+ */
+function spacingDefaults(suffix, shorthand) {
+  const values = parseShorthand(shorthand);
+
+  return Object.fromEntries(
+    SIDES.map((side, i) => [toCamelCase(`${suffix} ${side}`), values[i]])
+  );
+}
+
+function marginDefaults(suffix, shorthand) {
+  return spacingDefaults(suffix, shorthand);
+}
+
+function paddingDefaults(suffix, shorthand) {
+  return spacingDefaults(suffix, shorthand);
+}
+
+/**
+ * Returns four field descriptors (top/right/bottom/left) with only suffix and type — no initialValue.
+ * Used when defaults are stored separately in the subgroup spec.
+ *
+ * @param {string} prefix - e.g. "margin" or "padding"
+ * @returns {object[]}
+ */
+function marginFields(prefix) {
+  return SIDES.map((side) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+  }));
+}
+
+function paddingFields(prefix) {
+  return SIDES.map((side) => ({
+    suffix: `${prefix} ${side}`,
+    type: ZAPPIFEST_FIELDS.number_input,
+  }));
+}
+
 /**
  * Appends new conditional_fields from conditions array
  * to config.conditional_fields
@@ -48,6 +166,13 @@ function createConditionalField(key, condition_value, category = "styles") {
 }
 
 module.exports = {
+  parseShorthand,
+  margin,
+  padding,
+  marginDefaults,
+  paddingDefaults,
+  marginFields,
+  paddingFields,
   withConditional,
   getConditionalKey,
   createConditionalField,

package/manifestUtils/keys.js

@@ -43,6 +43,7 @@ const TV_PLATFORMS = [
   "tvos_for_quickbrick",
   "samsung_tv",
   "lg_tv",
+  "vidaa",
   "vizio",
 ];
 
@@ -630,6 +631,14 @@ const MOBILE_ACTION_BUTTON_FIELDS = [
     type: ZAPPIFEST_FIELDS.number_input,
     suffix: "margin left",
   },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "horizontal gutter",
+  },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "vertical gutter",
+  },
 ];
 
 const TV_MENU_LABEL_FIELDS = [

package/manifestUtils/mobileAction/button/index.js

@@ -129,6 +129,22 @@ function mobileActionButton({ label, description, defaults, isFirstButton }) {
       conditions.push(createConditionalField(labelEnabledKey, true));
     }
 
+    const assetAlignmentKey = keyPrefixGenerator("asset_alignment");
+
+    // horizontal_gutter fields depends on [asset_alignment: left or asset_alignment: right]
+    if (isKeyHasSuffix("horizontal_gutter", key)) {
+      conditions.push(
+        createConditionalField(assetAlignmentKey, ["left", "right"])
+      );
+    }
+
+    // vertical_gutter fields depends on [asset_alignment: above or asset_alignment: below]
+    if (isKeyHasSuffix("vertical_gutter", key)) {
+      conditions.push(
+        createConditionalField(assetAlignmentKey, ["above", "below"])
+      );
+    }
+
     return withConditional(conditions)(field);
   });
 

package/manifestUtils/mobileAction/container/index.js

@@ -49,7 +49,9 @@ function mobileActionButtonsContainer({ label, description, defaults }) {
 
     // over_image_position depends on [positionKey: over_image]
     if (isKeyHasSuffix("over_image_position", key)) {
-      conditions.push(createConditionalField(positionKey, "over_image"));
+      conditions.push(
+        createConditionalField(positionKey, defaults.position[0])
+      );
     }
 
     // horizontal_gutter depends on [stackingKey: horizontal]

package/manifestUtils/mobileAction/groups/defaults.js

@@ -33,7 +33,7 @@ const DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS = {
   assetHeight: 24,
   assetWidth: 24,
   assetMarginTop: 0,
-  assetMarginRight: 6,
+  assetMarginRight: 0,
   assetMarginBottom: 0,
   assetMarginLeft: 0,
   labelEnabled: true,
@@ -50,6 +50,8 @@ const DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS = {
   marginRight: 0,
   marginBottom: 0,
   marginLeft: 0,
+  horizontalGutter: 8,
+  verticalGutter: 8,
 };
 
 const DEFAULT_MOBILE_ACTION_BUTTON_PRESETS = {

package/manifestUtils/platformIsTV.js

@@ -4,6 +4,7 @@ function platformIsTV(platform) {
     "android_tv_for_quickbrick",
     "amazon_fire_tv_for_quickbrick",
     "lg_tv",
+    "vidaa",
     "samsung_tv",
     "web",
     "vizio",

package/modalState/ContentViewModel.ts

@@ -0,0 +1,111 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import {
+  Content,
+  MenuItem,
+  SelectionBehavior,
+  DynamicCollectionOptions,
+} from "./types";
+import { loadItemsFromSource } from "../actionsExecutor/actions/openBottomSheet";
+import { resolveEditableCollection } from "./EditableCollectionRegistry";
+import { EditableCollection } from "./EditableCollection";
+
+export interface ContentState {
+  items: MenuItem[];
+  isLoading: boolean;
+  error?: Error | string;
+  role?: string;
+  behavior?: SelectionBehavior;
+  dynamicCollection?: DynamicCollectionOptions;
+}
+
+export class ContentViewModel {
+  private state$: BehaviorSubject<ContentState>;
+  readonly itemsUrl?: string;
+  public editableCollection: EditableCollection | null = null;
+  private content: Content;
+
+  constructor(content: Content) {
+    this.content = content;
+    this.itemsUrl = content.itemsUrl;
+
+    this.state$ = new BehaviorSubject<ContentState>({
+      items: content.items || [],
+      isLoading: false,
+      role: content.role,
+      behavior: content.behavior,
+      dynamicCollection: content.dynamicCollection,
+    });
+
+    this.initEditableCollection(content);
+
+    if (this.itemsUrl && this.state$.value.items.length === 0) {
+      this.refetch();
+    }
+  }
+
+  private initEditableCollection(content: Content) {
+    this.editableCollection = resolveEditableCollection(content, this.refetch);
+  }
+
+  getState = (): ContentState => this.state$.value;
+
+  get stateObservable(): Observable<ContentState> {
+    return this.state$.asObservable();
+  }
+
+  subscribe = (listener: (state: ContentState) => void) => {
+    const subscription = this.state$.subscribe(listener);
+
+    return () => subscription.unsubscribe();
+  };
+
+  private updateState(partialState: Partial<ContentState>) {
+    this.state$.next({ ...this.state$.value, ...partialState });
+  }
+
+  refetch = async () => {
+    if (!this.itemsUrl) return;
+
+    this.updateState({ isLoading: true, error: undefined });
+
+    try {
+      const separator = this.itemsUrl.includes("?") ? "&" : "?";
+      const cacheBustedUrl = `${this.itemsUrl}${separator}_t=${Date.now()}`;
+
+      const { items, role, behavior, dynamicCollection } =
+        await loadItemsFromSource(cacheBustedUrl);
+
+      this.content = {
+        ...this.content,
+        items,
+        role,
+        behavior,
+        dynamicCollection,
+      };
+
+      this.updateState({
+        items,
+        role,
+        behavior,
+        dynamicCollection,
+        isLoading: false,
+      });
+
+      if (this.editableCollection) {
+        // Reuse the existing collection instance. Pushing the freshly loaded
+        // server items replaces any optimistic local state with the
+        // authoritative result (and rolls forward a successful mutation).
+        this.editableCollection.sync?.(items);
+      } else {
+        // The collection may only become resolvable once options arrive from
+        // the feed (e.g. inline content had none). Create it lazily here.
+        this.initEditableCollection(this.content);
+      }
+    } catch (err) {
+      this.updateState({
+        error: err?.message || "Failed to load",
+        isLoading: false,
+      });
+    }
+  };
+}

package/modalState/EditableCollection.ts

@@ -0,0 +1,17 @@
+import { Observable } from "rxjs";
+import { MenuItem, Operation } from "./types";
+
+export interface EditableCollection {
+  items$: Observable<MenuItem[]>;
+  operations: Operation[];
+  add?(item?: MenuItem): void | Promise<void>;
+  remove?(index: number): void | Promise<void>;
+  move?(itemIds: string[]): void | Promise<void>;
+  deleteCollection?(): void | Promise<void>;
+  /**
+   * Push authoritative items (e.g. a fresh server feed after a mutation) into
+   * the collection, replacing any optimistic local state. Called by the
+   * ContentViewModel on refetch so the instance is reused instead of recreated.
+   */
+  sync?(items: MenuItem[]): void;
+}

package/modalState/EditableCollectionRegistry.ts

@@ -0,0 +1,51 @@
+import { Content } from "./types";
+import { EditableCollection } from "./EditableCollection";
+import { RemoteEditableCollection } from "./RemoteEditableCollection";
+import { createLogger } from "../logger";
+
+const { log_error } = createLogger({
+  subsystem: "modalState",
+  category: "EditableCollectionRegistry",
+});
+
+type ProviderFactory = () => EditableCollection;
+
+export class EditableCollectionRegistry {
+  private static providers: Record<string, ProviderFactory> = {};
+
+  static register(token: string, factory: ProviderFactory) {
+    this.providers[token] = factory;
+  }
+
+  static getProvider(token: string): EditableCollection | null {
+    const factory = this.providers[token];
+
+    return factory ? factory() : null;
+  }
+}
+
+export function resolveEditableCollection(
+  content: Content,
+  refetch: () => Promise<void>
+): EditableCollection | null {
+  const options = content.dynamicCollection;
+  if (!options) return null;
+
+  if (options.provider) {
+    const provider = EditableCollectionRegistry.getProvider(options.provider);
+
+    if (!provider) {
+      log_error(
+        `No EditableCollection provider registered for token "${options.provider}"`
+      );
+    }
+
+    return provider;
+  }
+
+  if (options.postUrl) {
+    return new RemoteEditableCollection(content, refetch);
+  }
+
+  return null;
+}

package/modalState/ModalOrchestrator.ts

@@ -0,0 +1,198 @@
+import { dismissModal, modalStore, openBottomSheetModal } from "./store";
+import { isPresentSubMenuAction, Menu, MenuItem } from "./types";
+import { ContentViewModel } from "./ContentViewModel";
+
+export type { Menu, MenuItem };
+
+export { isPresentSubMenuAction };
+
+/**
+ * Converts a Menu model into the props expected by BottomSheetModalContent.
+ * - Maps MenuItem.title → label (required by BottomSheetModalContent)
+ * - Maps MenuItem.icon  → image src
+ * - Flattens header.title / header.subtitle into top-level title / summary
+ */
+interface StackEntry {
+  menu: Menu;
+  onItemPress?: (item: MenuItem) => void | Promise<void>;
+  viewModel: ContentViewModel;
+}
+
+function menuToModalArgs(
+  menu: Menu,
+  viewModel: ContentViewModel,
+  onItemPress: (item: MenuItem) => void | Promise<void>,
+  key: string
+): OpenModalBottomSheetArgs {
+  const items = menu.content.items.map((item) => ({
+    ...item,
+    // BottomSheetModalContent renders `theme[item.label] ?? item.label`
+    label: item.title,
+  }));
+
+  return {
+    modalBottomSheetContentProps: {
+      key,
+      items,
+      itemsUrl: menu.content.itemsUrl,
+      title: menu.header?.title ?? menu.content.title,
+      summary: menu.header?.subtitle,
+      onPress: onItemPress,
+      viewModel,
+    },
+    options: {},
+  };
+}
+
+/**
+ * ModalOrchestrator manages a stack of Menu modals, enabling push/pop
+ * navigation between bottom sheet screens.
+ *
+ * Usage:
+ *   modalOrchestrator.open(menu);
+ *   modalOrchestrator.back();    // go to previous modal in the stack
+ *   modalOrchestrator.close();   // dismiss all and clear the stack
+ */
+class ModalOrchestrator {
+  private _stack: StackEntry[] = [];
+
+  /** Number of entries currently in the stack. */
+  get stackSize(): number {
+    return this._stack.length;
+  }
+
+  /** Whether there is a previous modal to go back to. */
+  get canGoBack(): boolean {
+    return this._stack.length > 1;
+  }
+
+  /** The Menu currently shown, or null if the stack is empty. */
+  get current(): Menu | null {
+    return this._stack[this._stack.length - 1]?.menu ?? null;
+  }
+
+  /**
+   * Push a new Menu onto the stack and display it.
+   * If a menu item carries a PresentSubMenuAction it will automatically
+   * push the sub-menu when pressed; all other items delegate to
+   * the optional `onItemPress` callback.
+   */
+  open(
+    menu: Menu,
+    onItemPress?: (item: MenuItem) => void | Promise<void>
+  ): void {
+    const viewModel = new ContentViewModel(menu.content);
+    this._stack.push({ menu, onItemPress, viewModel });
+    this._present(menu, viewModel, onItemPress);
+  }
+
+  /**
+   * Pop the current modal and return to the previous one.
+   * If the stack has only one entry, closes entirely.
+   */
+  back(): void {
+    if (this._stack.length === 0) {
+      return;
+    }
+
+    this._stack.pop();
+
+    const previous = this._stack[this._stack.length - 1];
+
+    if (previous) {
+      this._present(previous.menu, previous.viewModel, previous.onItemPress);
+    } else {
+      dismissModal();
+    }
+  }
+
+  /**
+   * Close all modals and clear the entire stack.
+   */
+  close(): void {
+    this._stack = [];
+    dismissModal();
+  }
+
+  /**
+   * Replace the current top of the stack without adding a new history entry.
+   */
+  replace(
+    menu: Menu,
+    onItemPress?: (item: MenuItem) => void | Promise<void>
+  ): void {
+    if (this._stack.length === 0) {
+      this.open(menu, onItemPress);
+
+      return;
+    }
+
+    const viewModel = new ContentViewModel(menu.content);
+    this._stack[this._stack.length - 1] = { menu, onItemPress, viewModel };
+    this._present(menu, viewModel, onItemPress);
+  }
+
+  private _buildOnPress(
+    onItemPress?: (item: MenuItem) => void | Promise<void>
+  ): (item: MenuItem) => void | Promise<void> {
+    return (item: MenuItem) => {
+      if (isPresentSubMenuAction(item.action)) {
+        // Navigate deeper into the sub-menu
+        this.open(item.action.menu, onItemPress);
+
+        return;
+      }
+
+      return onItemPress?.(item);
+    };
+  }
+
+  /**
+   * Called when the UI dismisses the modal (swipe / overlay tap).
+   * Clears the stack without calling dismissModal() again to avoid
+   * a feedback loop with the store reset.
+   */
+  private _onUIDismiss(): void {
+    this._stack = [];
+  }
+
+  /**
+   * True when the Zustand modal store already has a visible bottom sheet.
+   * Used to skip the slide-in animation when navigating to a deeper level.
+   */
+  private get _isOpen(): boolean {
+    return modalStore.getState().modalState.visible;
+  }
+
+  private _present(
+    menu: Menu,
+    viewModel: ContentViewModel,
+    onItemPress?: (item: MenuItem) => void | Promise<void>
+  ): void {
+    const key = `menu-level-${this._stack.length}`;
+
+    const args = menuToModalArgs(
+      menu,
+      viewModel,
+      this._buildOnPress(onItemPress),
+      key
+    );
+
+    const alreadyOpen = this._isOpen;
+
+    openBottomSheetModal({
+      ...args,
+      options: {
+        ...args.options,
+        // Skip the slide-in when updating an already-visible sheet (sub-level nav)
+        animated: !alreadyOpen,
+        animationType: alreadyOpen ? "none" : "slide",
+        // Keep the stack in sync when the user dismisses via swipe or overlay
+        onDismiss: () => this._onUIDismiss(),
+        onRequestClose: () => this._onUIDismiss(),
+      },
+    });
+  }
+}
+
+export const modalOrchestrator = new ModalOrchestrator();