@iternio/react-native-auto-play 0.5.14-beta.1 → 0.6.0

package/lib/templates/MessageTemplate.d.ts

@@ -1,12 +1,14 @@
-import type { AutoImage, BaseMapTemplateConfig, CustomActionButtonAndroid, HeaderActionsAndroid, TextButton } from '..';
+import type { AutoImage, BaseMapTemplateConfig, CustomActionButtonAndroid, HeaderActions, TextButton } from '..';
 import type { AutoText } from '../types/Text';
 import { type NitroAction } from '../utils/NitroAction';
 import { type NitroImage } from '../utils/NitroImage';
+import type { PanelActionsIos, PanelHeaderActions } from './MapTemplate';
 import type { NitroBaseMapTemplateConfig, TemplateConfig } from './Template';
 export interface NitroMessageTemplateConfig extends TemplateConfig {
     headerActions?: Array<NitroAction>;
     /**
      * @namespace Android title shown on header
+     * @namespace iOS title shown when mapConfig is set, otherwise it isn't supported
      */
     title?: AutoText;
     message: AutoText;
@@ -14,31 +16,69 @@ export interface NitroMessageTemplateConfig extends TemplateConfig {
     image?: NitroImage;
     mapConfig?: NitroBaseMapTemplateConfig;
 }
-export type MessageTemplateConfig = Omit<NitroMessageTemplateConfig, 'headerActions' | 'image' | 'mapConfig' | 'actions'> & {
+type MessageActionsAndroid<T> = [CustomActionButtonAndroid<T>] | [CustomActionButtonAndroid<T>, CustomActionButtonAndroid<T>];
+type MessageTemplateBaseConfig = Omit<NitroMessageTemplateConfig, 'headerActions' | 'image' | 'mapConfig' | 'actions'> & {
     /**
      * action buttons, usually at the top right on Android
-     * @namespace Android
+     * @namespace iOS `ios` only takes effect once this renders as a CPMapPanel (`mapConfig` set,
+     * iOS 27+) and is applied to the root map template's nav bar — without `mapConfig` (or below
+     * iOS 27, where `mapConfig` is a no-op) this template is a full-screen `CPAlertTemplate`, which
+     * has no nav bar at all, so `ios` is silently unused there.
      */
-    headerActions?: HeaderActionsAndroid<MessageTemplate>;
+    headerActions?: HeaderActions<MessageTemplate>;
     /**
      * image shown at the top of the message on Android
      * @namespace Android
      */
     image?: AutoImage;
+};
+/**
+ * `actions`/`mapConfig` are a discriminated union — `mapConfig` restricts `actions.ios` to at
+ * most one `TextButton` plus one icon-only `ImageButton` (a `CPMapPanel` can't show more), vs. up
+ * to three `TextButton`s otherwise. If your `mapConfig` value comes from a variable/prop rather
+ * than an inline literal, TS can't narrow which branch applies — assign it to a local `const` and
+ * branch with `if (mapConfig) { ... } else { ... }` into two separate constructor calls instead
+ * of passing it straight through to one.
+ */
+export type MessageTemplateConfig = MessageTemplateBaseConfig & ({
+    mapConfig?: undefined;
     /**
-     * If mapConfig is defined, it will use a MapWithContentTemplate with the current template. This results in a MessageTemplate with a map in background. No actions need to be specified, can be empty object.
-     * @namespace Android
+     * @namespace Android up to 2 buttons of type TextButton, TextAndImageButton or ImageButton
+     * @namespace iOS - up to 3 buttons of type TextButton
      */
-    mapConfig?: BaseMapTemplateConfig<MessageTemplate>;
+    actions?: {
+        android?: MessageActionsAndroid<MessageTemplate>;
+        ios?: [
+            TextButton<MessageTemplate>,
+            TextButton<MessageTemplate>,
+            TextButton<MessageTemplate>
+        ] | [TextButton<MessageTemplate>, TextButton<MessageTemplate>] | [TextButton<MessageTemplate>];
+    };
+} | {
+    /**
+     * If mapConfig is defined, it will use a MapWithContentTemplate with the current
+     * template. This results in a MessageTemplate with a map in background. No actions
+     * need to be specified, can be empty object.
+     * @namespace Android - uses MapWithContentTemplate
+     * @namespace iOS - renders as a CPMapPanel on the current root map template (iOS 27+),
+     * trading the usual full-screen modal alert presentation for panel content;
+     * `headerActions` here is Android-only — on iOS this template's own `headerActions` are
+     * applied to the root map template's nav bar instead, since CarPlay has no separate
+     * header for the map behind a panel.
+     */
+    mapConfig: Omit<BaseMapTemplateConfig<MessageTemplate>, 'headerActions'> & {
+        headerActions?: PanelHeaderActions<MessageTemplate>;
+    };
     /**
      * @namespace Android up to 2 buttons of type TextButton, TextAndImageButton or ImageButton
-     * @namespace iOS - up to 3 buttons of type TextButton
+     * @namespace iOS - the panel can only show one TextButton plus one optional icon-only
+     * ImageButton, see PanelActionsIos
      */
     actions?: {
-        android?: [CustomActionButtonAndroid<MessageTemplate>] | [CustomActionButtonAndroid<MessageTemplate>, CustomActionButtonAndroid<MessageTemplate>];
-        ios?: [TextButton<MessageTemplate>, TextButton<MessageTemplate>, TextButton<MessageTemplate>] | [TextButton<MessageTemplate>, TextButton<MessageTemplate>] | [TextButton<MessageTemplate>];
+        android?: MessageActionsAndroid<MessageTemplate>;
+        ios?: PanelActionsIos<MessageTemplate>;
     };
-};
+});
 /**
  * This template is always pushed on top and will stay on top until it is popped.
  * Other templates being pushed will end up below this one on the stack.
@@ -53,3 +93,4 @@ export declare class MessageTemplate {
      */
     push(): Promise<void>;
 }
+export {};

package/lib/templates/MessageTemplate.js

@@ -22,7 +22,7 @@ export class MessageTemplate {
         const nitroConfig = {
             ...rest,
             id: this.id,
-            headerActions: NitroActionUtil.convert(this.template, { android: headerActions }),
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
             image: NitroImageUtil.convert(image),
             actions: platformActions,
             mapConfig: mapConfig

package/lib/utils/NitroOptionsPanel.d.ts

@@ -0,0 +1,103 @@
+import type { ImageButton, TextButton } from '../types/Button';
+import type { AutoImage } from '../types/Image';
+import type { AutoText, Distance } from '../types/Text';
+import type { DurationWithTimeZone } from '../types/Trip';
+import { type NitroAction } from './NitroAction';
+import { type GridButton, type NitroGridButton } from './NitroGrid';
+import { type NitroImage } from './NitroImage';
+import { type DefaultRow, type NitroSection, type RadioRow, type TextRow, type ToggleRow, type WaypointCoordinate, type WaypointRow } from './NitroSection';
+export type OptionsPanelGridSection<T> = {
+    type: 'grid';
+    title?: string;
+    buttons: Array<GridButton<T>>;
+};
+export type ChargingConnector = 'ccs1' | 'ccs2' | 'j1772' | 'chaDeMo' | 'mennekes' | 'gbtDC' | 'gbtAC' | 'nacsDC' | 'nacsAC';
+/**
+ * one outlet (`CPChargingStationConnection`) on a charging station.
+ */
+export type ChargerOutlet<T> = {
+    connector: ChargingConnector;
+    voltage: number;
+    /** converted to megawatts on the native side above 1000 kW */
+    powerKw: number;
+    onPress?: (template: T) => void;
+};
+/**
+ * the charging station's own location, shown as an additional `CPMapTemplateWaypoint` item in
+ * the charger section, alongside its outlets.
+ */
+export type ChargerLocation<T> = {
+    /**
+     * the item's own label — distinct from the section's `title`, which is already shown as the
+     * section header, so this defaults to blank rather than repeating it.
+     */
+    name?: string;
+    /** newline-separated address lines, most-preferred first */
+    address?: string;
+    coordinate: WaypointCoordinate;
+    travelEstimates: {
+        distance: Distance;
+        duration: DurationWithTimeZone;
+        /**
+         * by default travel estimates are not shown
+         * setting this to true add another row showing CPTravelEstimates
+         */
+        visible?: boolean;
+    };
+    image?: AutoImage;
+    onPress?: (template: T) => void;
+};
+/**
+ * charger section having n-ChargerOutlet
+ */
+export type OptionsPanelChargerSection<T> = {
+    type: 'charger';
+    title?: string;
+    outlets: Array<ChargerOutlet<T>>;
+    location?: ChargerLocation<T>;
+};
+export type OptionsPanelListSection<T> = {
+    type: 'list';
+    title?: string;
+    items: Array<DefaultRow<T> | ToggleRow<T> | TextRow | WaypointRow<T>> | Array<RadioRow<T>>;
+};
+export type OptionsPanelSection<T> = OptionsPanelListSection<T> | OptionsPanelGridSection<T> | OptionsPanelChargerSection<T>;
+export type OptionsPanelConfig<T> = {
+    title?: AutoText;
+    sections: Array<OptionsPanelSection<T>>;
+    actions?: [TextButton<T>] | [TextButton<T>, ImageButton<T>];
+};
+export type NitroOptionsPanelGridSection = {
+    title?: string;
+    buttons: Array<NitroGridButton>;
+};
+export type NitroChargerOutlet = {
+    connector: ChargingConnector;
+    voltage: number;
+    powerKw: number;
+    onPress?: () => void;
+};
+export type NitroChargerLocation = {
+    name?: string;
+    address?: string;
+    coordinate: WaypointCoordinate;
+    distance: Distance;
+    duration: DurationWithTimeZone;
+    visible?: boolean;
+    image?: NitroImage;
+    onPress?: () => void;
+};
+export type NitroOptionsPanelChargerSection = {
+    title?: string;
+    outlets: Array<NitroChargerOutlet>;
+    location?: NitroChargerLocation;
+};
+export type NitroOptionsPanelSection = NitroSection | NitroOptionsPanelGridSection | NitroOptionsPanelChargerSection;
+export type NitroOptionsPanelConfig = {
+    title?: AutoText;
+    sections: Array<NitroOptionsPanelSection>;
+    actions?: Array<NitroAction>;
+};
+export declare const NitroOptionsPanelUtil: {
+    convert: <T>(template: T, config?: OptionsPanelConfig<T>) => NitroOptionsPanelConfig | undefined;
+};

package/lib/utils/NitroOptionsPanel.js

@@ -0,0 +1,63 @@
+import { NitroActionUtil } from './NitroAction';
+import { NitroGridUtil } from './NitroGrid';
+import { NitroImageUtil } from './NitroImage';
+import { NitroSectionUtil, } from './NitroSection';
+const isRadioSection = (items) => {
+    return items.length > 0 && items.every((item) => item.type === 'radio');
+};
+const convertSection = (template, section) => {
+    if (section.type === 'grid') {
+        return {
+            title: section.title,
+            buttons: NitroGridUtil.convert(template, section.buttons),
+        };
+    }
+    if (section.type === 'charger') {
+        const { location } = section;
+        return {
+            title: section.title,
+            outlets: section.outlets.map((outlet) => ({
+                connector: outlet.connector,
+                voltage: outlet.voltage,
+                powerKw: outlet.powerKw,
+                onPress: outlet.onPress ? () => outlet.onPress?.(template) : undefined,
+            })),
+            location: location
+                ? {
+                    name: location.name,
+                    address: location.address,
+                    coordinate: location.coordinate,
+                    distance: location.travelEstimates.distance,
+                    duration: location.travelEstimates.duration,
+                    visible: location.travelEstimates.visible,
+                    image: NitroImageUtil.convert(location.image),
+                    onPress: location.onPress ? () => location.onPress?.(template) : undefined,
+                }
+                : undefined,
+        };
+    }
+    const { items, title = '' } = section;
+    const multiSection = isRadioSection(items)
+        ? { type: 'radio', title, items }
+        : {
+            type: 'default',
+            title,
+            items,
+        };
+    const [nitroSection] = NitroSectionUtil.convert(template, [multiSection]) ?? [];
+    if (nitroSection == null) {
+        throw new Error('converting sections failed');
+    }
+    return nitroSection;
+};
+const convert = (template, config) => {
+    if (config == null) {
+        return undefined;
+    }
+    return {
+        title: config.title,
+        sections: config.sections.map((section) => convertSection(template, section)),
+        actions: NitroActionUtil.convert(template, config.actions),
+    };
+};
+export const NitroOptionsPanelUtil = { convert };

package/lib/utils/NitroSection.d.ts

@@ -1,6 +1,82 @@
-import type { Section } from '../templates/ListTemplate';
-import type { AutoText } from '../types/Text';
+import type { ListImageType } from '../templates/ListTemplate';
+import type { AutoImage } from '../types/Image';
+import { type AutoText, type Distance } from '../types/Text';
+import type { DurationWithTimeZone } from '../types/Trip';
 import { type NitroImage } from './NitroImage';
+type BaseRow = {
+    title: AutoText;
+    enabled?: boolean;
+    image?: AutoImage;
+    /** @namespace Android */
+    imageType?: ListImageType;
+};
+export type DefaultRow<T> = BaseRow & {
+    type: 'default';
+    /**
+     * adds a chevron at the end of the row
+     */
+    browsable?: boolean;
+    onPress: (template: T) => void;
+    detailedText?: AutoText;
+};
+export type ToggleRow<T> = BaseRow & {
+    type: 'toggle';
+    checked: boolean;
+    onPress: (template: T, checked: boolean) => void;
+};
+export type RadioRow<T> = BaseRow & {
+    type: 'radio';
+    onPress: (template: T) => void;
+    selected?: boolean;
+};
+export type TextRow = BaseRow & {
+    type: 'text';
+    detailedText?: AutoText;
+};
+export type WaypointCoordinate = {
+    latitude: number;
+    longitude: number;
+    altitude?: number;
+};
+/**
+ * a point of interest, e.g. a charger's location. Renders as a `CPMapTemplateWaypoint` item
+ * (showing `title` as the name, `address` as the address, and the travel estimate for reaching
+ * it) when part of a `CPMapPanel` (iOS 27+); falls back to a plain row using `title`/`address`
+ * as the detail line everywhere else (including Android, which has no equivalent concept).
+ */
+export type WaypointRow<T> = BaseRow & {
+    type: 'waypoint';
+    /**
+     * add one of {@link TextPlaceholders} to add travelEstimates
+     * prefer travelEstimates.visible over that on iOS 27+
+     */
+    address?: string;
+    coordinate: WaypointCoordinate;
+    travelEstimates: {
+        distance: Distance;
+        duration: DurationWithTimeZone;
+        /**
+         * by default travel estimates are not shown
+         * setting this to true adds another row showing CPTravelEstimates
+         * @namespace iOS 27+
+         */
+        visible?: boolean;
+    };
+    onPress?: (template: T) => void;
+};
+export type MultiSection<T> = {
+    type: 'default';
+    title: string;
+    items: Array<DefaultRow<T> | ToggleRow<T> | TextRow | WaypointRow<T>>;
+} | {
+    type: 'radio';
+    title: string;
+    items: Array<RadioRow<T>>;
+};
+export type SingleSection<T> = {
+    [K in MultiSection<T> as K['type']]: Omit<K, 'title' | 'detailedText'>;
+}[MultiSection<T>['type']];
+export type Section<T> = Array<MultiSection<T>> | SingleSection<T>;
 type NitroSectionType = 'default' | 'radio';
 export type NitroRow = {
     title: AutoText;
@@ -8,9 +84,20 @@ export type NitroRow = {
     browsable?: boolean;
     enabled: boolean;
     image?: NitroImage;
+    imageType?: ListImageType;
     checked?: boolean;
     onPress?: (checked?: boolean) => void;
     selected?: boolean;
+    coordinate?: WaypointCoordinate;
+    distance?: Distance;
+    duration?: DurationWithTimeZone;
+    /**
+     * only meaningful in panel context (iOS 27+, `mapConfig` set) — adds a sibling `CPMapPanelItem`
+     * showing `distance`/`duration` as a native `CPTravelEstimates` row. Non-panel/Android rendering
+     * relies purely on `title`/`detailedText` opting in via `TextPlaceholders` instead.
+     */
+    travelEstimatesVisible?: boolean;
+    address?: string;
 };
 export type NitroSection = {
     title?: string;

package/lib/utils/NitroSection.js

@@ -1,3 +1,4 @@
+import { TextPlaceholders } from '../types/Text';
 import { NitroImageUtil } from './NitroImage';
 const validateRadioItems = (type, items) => {
     if (__DEV__ &&
@@ -31,9 +32,49 @@ const convert = (template, sections) => {
         },
     ];
 };
+/**
+ * `AutoText.distance`/`.duration` only take effect if `text` actually uses the matching
+ * `TextPlaceholders` marker — populate whichever of those the text references, leaving the rest
+ * of `text` untouched, so a title/address that doesn't opt in via a placeholder is unaffected.
+ */
+const withTravelEstimates = (text, distance, durationSeconds) => {
+    const hasDistance = text.text.includes(TextPlaceholders.Distance);
+    const hasDuration = text.text.includes(TextPlaceholders.Duration);
+    if (!hasDistance && !hasDuration) {
+        return text;
+    }
+    return {
+        ...text,
+        distance: hasDistance ? distance : text.distance,
+        duration: hasDuration ? durationSeconds : text.duration,
+    };
+};
 const convertRow = (template, item) => {
-    const { title, type, enabled = true, image } = item;
-    const detailedText = 'detailedText' in item ? item.detailedText : undefined;
+    const { type, enabled = true, image, imageType } = item;
+    // `WaypointRow` has no `detailedText` of its own — `address` doubles as the detail line
+    // whenever this falls back to a plain row (non-panel context, Android).
+    let title = item.title;
+    let detailedText = item.type === 'waypoint'
+        ? item.address != null
+            ? { text: item.address }
+            : undefined
+        : 'detailedText' in item
+            ? item.detailedText
+            : undefined;
+    // Opt-in only: a title/address using `{distance}`/`{duration}` gets those values filled in,
+    // via the same substitution `AutoText` already does everywhere else — no separate "estimate"
+    // UI element needed for a row embedded in a list alongside other rows. Deliberately NOT gated
+    // on `travelEstimates.visible` — that flag only controls the panel-only sibling
+    // `CPTravelEstimates` item (see `Parser.swift`'s `travelEstimatesVisible` check), which has no
+    // bearing on the non-panel/Android fallback text this feeds; a placeholder in the text is
+    // already its own explicit opt-in regardless of `visible`.
+    if (item.type === 'waypoint') {
+        const { distance, duration } = item.travelEstimates;
+        title = withTravelEstimates(title, distance, duration.seconds);
+        if (detailedText != null) {
+            detailedText = withTravelEstimates(detailedText, distance, duration.seconds);
+        }
+    }
     const selected = type === 'radio' ? (item.selected ?? false) : undefined;
     const onTogglePress = item.type === 'toggle' ? item.onPress : undefined;
     const onRowPress = item.type !== 'text' && item.type !== 'toggle' ? item.onPress : undefined;
@@ -53,10 +94,16 @@ const convertRow = (template, item) => {
         detailedText,
         enabled,
         image: NitroImageUtil.convert(image),
+        imageType,
         title,
         checked: type === 'toggle' ? item.checked : undefined,
         onPress,
         selected,
+        coordinate: item.type === 'waypoint' ? item.coordinate : undefined,
+        distance: item.type === 'waypoint' ? item.travelEstimates.distance : undefined,
+        duration: item.type === 'waypoint' ? item.travelEstimates.duration : undefined,
+        travelEstimatesVisible: item.type === 'waypoint' ? item.travelEstimates.visible : undefined,
+        address: item.type === 'waypoint' ? item.address : undefined,
     };
 };
 export const NitroSectionUtil = { convert };

package/nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake

@@ -61,6 +61,7 @@ target_sources(
   ../nitrogen/generated/android/c++/JHybridMapTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JNitroManeuver.cpp
   ../nitrogen/generated/android/c++/JVariant_PreferredImageLane_ImageLane.cpp
+  ../nitrogen/generated/android/c++/JNitroOptionsPanelSection.cpp
   ../nitrogen/generated/android/c++/JHybridMessageTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JHybridSearchTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JHybridSignInTemplateSpec.cpp

package/nitrogen/generated/android/c++/JChargingConnector.hpp

@@ -0,0 +1,79 @@
+///
+/// JChargingConnector.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ChargingConnector.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ChargingConnector" and the the Kotlin enum "ChargingConnector".
+   */
+  struct JChargingConnector final: public jni::JavaClass<JChargingConnector> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/ChargingConnector;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ChargingConnector.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ChargingConnector toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ChargingConnector>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JChargingConnector> fromCpp(ChargingConnector value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case ChargingConnector::CCS1:
+          static const auto fieldCCS1 = clazz->getStaticField<JChargingConnector>("CCS1");
+          return clazz->getStaticFieldValue(fieldCCS1);
+        case ChargingConnector::CCS2:
+          static const auto fieldCCS2 = clazz->getStaticField<JChargingConnector>("CCS2");
+          return clazz->getStaticFieldValue(fieldCCS2);
+        case ChargingConnector::J1772:
+          static const auto fieldJ1772 = clazz->getStaticField<JChargingConnector>("J1772");
+          return clazz->getStaticFieldValue(fieldJ1772);
+        case ChargingConnector::CHADEMO:
+          static const auto fieldCHADEMO = clazz->getStaticField<JChargingConnector>("CHADEMO");
+          return clazz->getStaticFieldValue(fieldCHADEMO);
+        case ChargingConnector::MENNEKES:
+          static const auto fieldMENNEKES = clazz->getStaticField<JChargingConnector>("MENNEKES");
+          return clazz->getStaticFieldValue(fieldMENNEKES);
+        case ChargingConnector::GBTDC:
+          static const auto fieldGBTDC = clazz->getStaticField<JChargingConnector>("GBTDC");
+          return clazz->getStaticFieldValue(fieldGBTDC);
+        case ChargingConnector::GBTAC:
+          static const auto fieldGBTAC = clazz->getStaticField<JChargingConnector>("GBTAC");
+          return clazz->getStaticFieldValue(fieldGBTAC);
+        case ChargingConnector::NACSDC:
+          static const auto fieldNACSDC = clazz->getStaticField<JChargingConnector>("NACSDC");
+          return clazz->getStaticFieldValue(fieldNACSDC);
+        case ChargingConnector::NACSAC:
+          static const auto fieldNACSAC = clazz->getStaticField<JChargingConnector>("NACSAC");
+          return clazz->getStaticFieldValue(fieldNACSAC);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JGridImageSize.hpp

@@ -0,0 +1,64 @@
+///
+/// JGridImageSize.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "GridImageSize.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "GridImageSize" and the the Kotlin enum "GridImageSize".
+   */
+  struct JGridImageSize final: public jni::JavaClass<JGridImageSize> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/GridImageSize;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum GridImageSize.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GridImageSize toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<GridImageSize>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JGridImageSize> fromCpp(GridImageSize value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case GridImageSize::UNSET:
+          static const auto fieldUNSET = clazz->getStaticField<JGridImageSize>("UNSET");
+          return clazz->getStaticFieldValue(fieldUNSET);
+        case GridImageSize::LARGE:
+          static const auto fieldLARGE = clazz->getStaticField<JGridImageSize>("LARGE");
+          return clazz->getStaticFieldValue(fieldLARGE);
+        case GridImageSize::MEDIUM:
+          static const auto fieldMEDIUM = clazz->getStaticField<JGridImageSize>("MEDIUM");
+          return clazz->getStaticFieldValue(fieldMEDIUM);
+        case GridImageSize::SMALL:
+          static const auto fieldSMALL = clazz->getStaticField<JGridImageSize>("SMALL");
+          return clazz->getStaticFieldValue(fieldSMALL);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/c++/JGridTemplateConfig.hpp

@@ -15,6 +15,7 @@
 #include "Distance.hpp"
 #include "DistanceUnits.hpp"
 #include "GlyphImage.hpp"
+#include "GridImageSize.hpp"
 #include "JAssetImage.hpp"
 #include "JAutoText.hpp"
 #include "JDistance.hpp"
@@ -23,6 +24,7 @@
 #include "JFunc_void_bool.hpp"
 #include "JFunc_void_std__optional_bool_.hpp"
 #include "JGlyphImage.hpp"
+#include "JGridImageSize.hpp"
 #include "JNitroAction.hpp"
 #include "JNitroActionType.hpp"
 #include "JNitroAlignment.hpp"
@@ -91,6 +93,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       jni::local_ref<JAutoText> title = this->getFieldValue(fieldTitle);
       static const auto fieldButtons = clazz->getField<jni::JArrayClass<JNitroGridButton>>("buttons");
       jni::local_ref<jni::JArrayClass<JNitroGridButton>> buttons = this->getFieldValue(fieldButtons);
+      static const auto fieldImageSize = clazz->getField<JGridImageSize>("imageSize");
+      jni::local_ref<JGridImageSize> imageSize = this->getFieldValue(fieldImageSize);
       static const auto fieldMapConfig = clazz->getField<JNitroBaseMapTemplateConfig>("mapConfig");
       jni::local_ref<JNitroBaseMapTemplateConfig> mapConfig = this->getFieldValue(fieldMapConfig);
       return GridTemplateConfig(
@@ -162,6 +166,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
           }
           return __vector;
         }(buttons),
+        imageSize != nullptr ? std::make_optional(imageSize->toCpp()) : std::nullopt,
         mapConfig != nullptr ? std::make_optional(mapConfig->toCpp()) : std::nullopt
       );
     }
@@ -172,7 +177,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
      */
     [[maybe_unused]]
     static jni::local_ref<JGridTemplateConfig::javaobject> fromCpp(const GridTemplateConfig& value) {
-      using JSignature = JGridTemplateConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JArrayClass<JNitroAction>>, jni::alias_ref<JAutoText>, jni::alias_ref<jni::JArrayClass<JNitroGridButton>>, jni::alias_ref<JNitroBaseMapTemplateConfig>);
+      using JSignature = JGridTemplateConfig(jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void_std__optional_bool_::javaobject>, jni::alias_ref<JFunc_void::javaobject>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JArrayClass<JNitroAction>>, jni::alias_ref<JAutoText>, jni::alias_ref<jni::JArrayClass<JNitroGridButton>>, jni::alias_ref<JGridImageSize>, jni::alias_ref<JNitroBaseMapTemplateConfig>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -205,6 +210,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
           }
           return __array;
         }(value.buttons),
+        value.imageSize.has_value() ? JGridImageSize::fromCpp(value.imageSize.value()) : nullptr,
         value.mapConfig.has_value() ? JNitroBaseMapTemplateConfig::fromCpp(value.mapConfig.value()) : nullptr
       );
     }