@iternio/react-native-auto-play 0.6.0 → 0.6.1

package/lib-cjs/utils/NitroOptionsPanel.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NitroOptionsPanelUtil = void 0;
+const NitroAction_1 = require("./NitroAction");
+const NitroGrid_1 = require("./NitroGrid");
+const NitroImage_1 = require("./NitroImage");
+const NitroSection_1 = require("./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: NitroGrid_1.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: NitroImage_1.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] = NitroSection_1.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: NitroAction_1.NitroActionUtil.convert(template, config.actions),
+    };
+};
+exports.NitroOptionsPanelUtil = { convert };

package/lib-cjs/utils/NitroSection.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NitroSectionUtil = void 0;
+const Text_1 = require("../types/Text");
+const NitroImage_1 = require("./NitroImage");
+const validateRadioItems = (type, items) => {
+    if (__DEV__ &&
+        type === 'radio' &&
+        (items.filter((item) => item.selected).length > 1 || items.every((item) => !item.selected))) {
+        throw new Error('radio lists must have one selected item');
+    }
+};
+const convert = (template, sections) => {
+    if (sections == null) {
+        return undefined;
+    }
+    if (Array.isArray(sections)) {
+        return sections.map((section) => {
+            const { title, type } = section;
+            const items = section.items.map((item) => convertRow(template, item));
+            validateRadioItems(type, items);
+            return {
+                items,
+                type,
+                title,
+            };
+        });
+    }
+    const items = sections.items.map((item) => convertRow(template, item));
+    validateRadioItems(sections.type, items);
+    return [
+        {
+            items,
+            type: sections.type,
+        },
+    ];
+};
+/**
+ * `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(Text_1.TextPlaceholders.Distance);
+    const hasDuration = text.text.includes(Text_1.TextPlaceholders.Duration);
+    if (!hasDistance && !hasDuration) {
+        return text;
+    }
+    return {
+        ...text,
+        distance: hasDistance ? distance : text.distance,
+        duration: hasDuration ? durationSeconds : text.duration,
+    };
+};
+const convertRow = (template, item) => {
+    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;
+    const onPress = item.type === 'text'
+        ? undefined
+        : (checked) => {
+            if (onTogglePress != null && checked != null) {
+                onTogglePress(template, checked);
+                return;
+            }
+            if (onRowPress != null) {
+                onRowPress(template);
+            }
+        };
+    return {
+        browsable: type === 'default' ? item.browsable : undefined,
+        detailedText,
+        enabled,
+        image: NitroImage_1.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,
+    };
+};
+exports.NitroSectionUtil = { convert };

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

@@ -10,7 +10,7 @@
 #include <fbjni/fbjni.h>
 #include "NitroColor.hpp"
 
-
+#include <optional>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -35,9 +35,12 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       double lightColor = this->getFieldValue(fieldLightColor);
       static const auto fieldDarkColor = clazz->getField<double>("darkColor");
       double darkColor = this->getFieldValue(fieldDarkColor);
+      static const auto fieldIsDefault = clazz->getField<jni::JBoolean>("isDefault");
+      jni::local_ref<jni::JBoolean> isDefault = this->getFieldValue(fieldIsDefault);
       return NitroColor(
         lightColor,
-        darkColor
+        darkColor,
+        isDefault != nullptr ? std::make_optional(static_cast<bool>(isDefault->value())) : std::nullopt
       );
     }
 
@@ -47,13 +50,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
      */
     [[maybe_unused]]
     static jni::local_ref<JNitroColor::javaobject> fromCpp(const NitroColor& value) {
-      using JSignature = JNitroColor(double, double);
+      using JSignature = JNitroColor(double, double, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         value.lightColor,
-        value.darkColor
+        value.darkColor,
+        value.isDefault.has_value() ? jni::JBoolean::valueOf(value.isDefault.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/NitroColor.kt

@@ -23,7 +23,10 @@ data class NitroColor(
   val lightColor: Double,
   @DoNotStrip
   @Keep
-  val darkColor: Double
+  val darkColor: Double,
+  @DoNotStrip
+  @Keep
+  val isDefault: Boolean?
 ) {
   /* primary constructor */
 
@@ -32,12 +35,14 @@ data class NitroColor(
     if (other !is NitroColor) return false
     return Objects.deepEquals(this.lightColor, other.lightColor)
       && Objects.deepEquals(this.darkColor, other.darkColor)
+      && Objects.deepEquals(this.isDefault, other.isDefault)
   }
 
   override fun hashCode(): Int {
     return arrayOf<Any?>(
       lightColor,
-      darkColor
+      darkColor,
+      isDefault
     ).contentDeepHashCode()
   }
 
@@ -49,8 +54,8 @@ data class NitroColor(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(lightColor: Double, darkColor: Double): NitroColor {
-      return NitroColor(lightColor, darkColor)
+    private fun fromCpp(lightColor: Double, darkColor: Double, isDefault: Boolean?): NitroColor {
+      return NitroColor(lightColor, darkColor, isDefault)
     }
   }
 }

package/nitrogen/generated/ios/swift/NitroColor.swift

@@ -18,8 +18,14 @@ public extension NitroColor {
   /**
    * Create a new instance of `NitroColor`.
    */
-  init(lightColor: Double, darkColor: Double) {
-    self.init(lightColor, darkColor)
+  init(lightColor: Double, darkColor: Double, isDefault: Bool?) {
+    self.init(lightColor, darkColor, { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = isDefault {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
   }
 
   @inline(__always)
@@ -31,4 +37,16 @@ public extension NitroColor {
   var darkColor: Double {
     return self.__darkColor
   }
+  
+  @inline(__always)
+  var isDefault: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__isDefault) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__isDefault)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
 }

package/nitrogen/generated/shared/c++/NitroColor.hpp

@@ -30,7 +30,7 @@
 
 
 
-
+#include <optional>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -41,10 +41,11 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   public:
     double lightColor     SWIFT_PRIVATE;
     double darkColor     SWIFT_PRIVATE;
+    std::optional<bool> isDefault     SWIFT_PRIVATE;
 
   public:
     NitroColor() = default;
-    explicit NitroColor(double lightColor, double darkColor): lightColor(lightColor), darkColor(darkColor) {}
+    explicit NitroColor(double lightColor, double darkColor, std::optional<bool> isDefault): lightColor(lightColor), darkColor(darkColor), isDefault(isDefault) {}
 
   public:
     friend bool operator==(const NitroColor& lhs, const NitroColor& rhs) = default;
@@ -61,13 +62,15 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor(
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lightColor"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "darkColor")))
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "darkColor"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isDefault")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::NitroColor& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "lightColor"), JSIConverter<double>::toJSI(runtime, arg.lightColor));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "darkColor"), JSIConverter<double>::toJSI(runtime, arg.darkColor));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isDefault"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.isDefault));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -80,6 +83,7 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lightColor")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "darkColor")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isDefault")))) return false;
       return true;
     }
   };

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",
+  "browser": "lib/index.web",
   "types": "lib/index.d.ts",
   "react-native": "src/index",
   "source": "src/index",
@@ -11,6 +12,8 @@
     "src",
     "react-native.config.js",
     "lib",
+    "lib-cjs",
+    "jest.js",
     "nitrogen",
     "android/build.gradle",
     "android/gradle.properties",
@@ -30,12 +33,13 @@
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf android/build node_modules/**/android/build lib",
+    "clean": "rm -rf android/build node_modules/**/android/build lib lib-cjs",
     "lint": "biome check src",
     "lint-ci": "biome ci src --reporter=summary",
     "typescript": "tsc",
+    "build:jest": "tsc -p tsconfig.jest.json",
     "specs": "nitrogen --logLevel=\"debug\"",
-    "prepare": "yarn circular && tsc && nitrogen",
+    "prepare": "yarn circular && tsc && yarn build:jest && nitrogen",
     "swift:format": "swift-format format ./ios --in-place --recursive",
     "circular": "dpdm ./src/* --circular --exit-code circular:1 --no-tree --warning=false --transform"
   },

package/src/index.web.ts

@@ -0,0 +1,166 @@
+// Web/Jest stub for the native CarPlay/Android Auto surface. Nothing here talks to a real native
+// module — every function call resolves to `undefined` (or an already-resolved promise, which is
+// indistinguishable from `undefined` to an `await`er) rather than throwing. Types are preserved by
+// casting against the real exports, so callers still get full type-checking/autocomplete.
+//
+// Anything below that's already safe as-is (pure types, plain enums, or modules that neither
+// create native objects nor import anything that does) is re-exported directly instead of stubbed.
+
+import { createElement } from 'react';
+import { View, type ViewProps } from 'react-native';
+import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
+import type { AutoPlay } from './specs/AutoPlay.nitro';
+import type { Voice } from './specs/Voice.nitro';
+import type { GridTemplate as RealGridTemplate } from './templates/GridTemplate';
+import type { InformationTemplate as RealInformationTemplate } from './templates/InformationTemplate';
+import type { ListTemplate as RealListTemplate } from './templates/ListTemplate';
+import type { MapTemplate as RealMapTemplate } from './templates/MapTemplate';
+import type { MessageTemplate as RealMessageTemplate } from './templates/MessageTemplate';
+import type { SearchTemplate as RealSearchTemplate } from './templates/SearchTemplate';
+import type { SignInTemplate as RealSignInTemplate } from './templates/SignInTemplate';
+import type { Template as RealTemplate } from './templates/Template';
+import type { SafeAreaInsets } from './types/Event';
+import type { Telemetry } from './types/Telemetry';
+
+function noop() {
+  return undefined;
+}
+
+/** Any property access returns a no-op function, so any method call is safe regardless of name. */
+function createNoopObject<T>(): T {
+  return new Proxy(
+    {},
+    {
+      get: (_target, prop) => (prop === 'then' || prop === 'toJSON' ? undefined : noop),
+    }
+  ) as T;
+}
+
+function createNoopClass<T>(): new (...args: never[]) => T {
+  function NoopInstance() {
+    return createNoopObject<T>();
+  }
+  return NoopInstance as unknown as new (
+    ...args: never[]
+  ) => T;
+}
+
+export * from './Constants';
+export * from './hooks/useMapTemplate';
+export type {
+  ActiveCarUxRestrictions,
+  AppFocusState,
+} from './specs/AndroidAutomotive.nitro';
+export { CarUxRestrictions } from './specs/AndroidAutomotive.nitro';
+export type { GridImageSize, GridTemplateConfig } from './templates/GridTemplate';
+export type { InformationItems, InformationTemplateConfig } from './templates/InformationTemplate';
+export type {
+  DefaultRow,
+  ListImageType,
+  ListTemplateConfig,
+  MultiSection,
+  RadioRow,
+  Section,
+  SingleSection,
+  TextRow,
+  ToggleRow,
+  WaypointCoordinate,
+  WaypointRow,
+} from './templates/ListTemplate';
+export type {
+  BaseMapTemplateConfig,
+  ChargerLocation,
+  ChargerOutlet,
+  ChargingConnector,
+  HeaderActionsAndroidMap,
+  MapButtons,
+  MapHeaderActions,
+  MapTemplateConfig,
+  OptionsPanelChargerSection,
+  OptionsPanelConfig,
+  OptionsPanelGridSection,
+  OptionsPanelListSection,
+  OptionsPanelSection,
+  PanelActionsIos,
+  PanelHeaderActions,
+  Point,
+  TripSelectorCallback,
+  VisibleTravelEstimate,
+} from './templates/MapTemplate';
+export type { MessageTemplateConfig } from './templates/MessageTemplate';
+export type { SearchSection, SearchTemplateConfig } from './templates/SearchTemplate';
+export type { SignInTemplateConfig } from './templates/SignInTemplate';
+export type {
+  ActionButton,
+  HeaderActions,
+  HeaderActionsAndroid,
+  HeaderActionsIos,
+  NitroBaseMapTemplateConfig,
+  NitroTemplateConfig,
+  TemplateConfig,
+} from './templates/Template';
+export * from './types/Button';
+export * from './types/Event';
+export * from './types/Image';
+export * from './types/Maneuver';
+export * from './types/RootComponent';
+export * from './types/SignInMethod';
+export * from './types/Telemetry';
+export * from './types/Text';
+export * from './types/Trip';
+export type { VoiceInputChunk, VoiceInputOptions, VoiceInputResult } from './types/Voice';
+export * from './utils/ErrorUtil';
+export type {
+  AlertPriority,
+  NavigationAlert as Alert,
+  NavigationAlertAction as AlertAction,
+} from './utils/NitroAlert';
+export type { ThemedColor } from './utils/NitroColor';
+export type { GridButton } from './utils/NitroGrid';
+
+export enum AutoPlayModules {
+  App = 'main',
+  AutoPlayRoot = 'AutoPlayRoot',
+  CarPlayDashboard = 'CarPlayDashboard',
+}
+
+const NO_INSETS: SafeAreaInsets = { top: 0, bottom: 0, left: 0, right: 0 };
+export const useSafeAreaInsets = () => NO_INSETS;
+export const SafeAreaView = (props: ViewProps) => createElement(View, props);
+
+export function setIconFont(_name: string, _glyphMap?: Record<string, number>): void {}
+
+export const useFocusedEffect = () => {};
+
+export const useVoiceInput = () => ({
+  voiceInputResult: undefined,
+  resetVoiceInputResult: () => {},
+});
+
+export const useAndroidAutoTelemetry = (): {
+  permissionsGranted: boolean | null;
+  telemetry: Telemetry | undefined;
+  error: string | undefined;
+} => ({
+  permissionsGranted: null,
+  telemetry: undefined,
+  error: undefined,
+});
+
+export const AutoPlayCluster = createNoopObject<Record<string, unknown>>();
+export const CarPlayDashboard = createNoopObject<Record<string, unknown>>();
+
+export const HybridAndroidAutomotive: AndroidAutomotive | null = null;
+export { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
+export { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
+export const HybridAutoPlay = createNoopObject<AutoPlay>();
+export const HybridVoice = createNoopObject<Voice>();
+
+export const Template = createNoopClass<InstanceType<typeof RealTemplate>>();
+export const ListTemplate = createNoopClass<RealListTemplate>();
+export const GridTemplate = createNoopClass<RealGridTemplate>();
+export const InformationTemplate = createNoopClass<RealInformationTemplate>();
+export const MessageTemplate = createNoopClass<RealMessageTemplate>();
+export const MapTemplate = createNoopClass<RealMapTemplate>();
+export const SearchTemplate = createNoopClass<RealSearchTemplate>();
+export const SignInTemplate = createNoopClass<RealSignInTemplate>();

package/src/types/Image.ts

@@ -24,7 +24,8 @@ export type GlyphMapKey = keyof AutoPlayGlyphMap extends never
 type GlyphStyleFields = {
   /**
    * Sets the icon dark and light mode color or a single color for both.
-   * Defaults to white for dark mode and black for light mode if not specified.
+   * Defaults to `'default'` if not specified, which is white for dark mode and black for light mode.
+   * On Android Auto the host tint that follows the template is not applied when `backgroundColor` is not transparent.
    * Might not get applied everywhere like MapTemplate buttons on Android.
    */
   color?: ThemedColor | string;
@@ -61,6 +62,8 @@ export type AutoImage =
       /**
        * if specified the image gets tinted, if not it will just use the original image
        * Might not get applied everywhere like MapTemplate buttons on Android.
+       * Use `'default'` for monochrome icons that must stay readable on both dark and light
+       * Android Auto templates (17.8+), see README.
        */
       color?: ThemedColor | string;
       type: 'asset';
@@ -70,6 +73,8 @@ export type AutoImage =
       uri: string;
       /**
        * if specified the image gets tinted, if not it will just use the original image
+       * Use `'default'` for monochrome icons that must stay readable on both dark and light
+       * Android Auto templates (17.8+), see README.
        */
       color?: ThemedColor | string;
       /**

package/src/utils/NitroColor.ts

@@ -1,8 +1,14 @@
 import { processColor } from 'react-native';
 
-export type NitroColor = { lightColor: number; darkColor: number };
+export type NitroColor = { lightColor: number; darkColor: number; isDefault?: boolean };
 export type ThemedColor = { lightColor: string; darkColor: string };
 
+const DefaultNitroColor = {
+  darkColor: convertColor('white'),
+  lightColor: convertColor('black'),
+  isDefault: true,
+};
+
 function convertColor(color: string): number;
 function convertColor(color?: string): number | undefined;
 function convertColor(color?: string): number | undefined {
@@ -18,6 +24,9 @@ function convert(color?: ThemedColor | string): NitroColor | undefined {
   }
 
   if (typeof color === 'string') {
+    if (color === 'default') {
+      return DefaultNitroColor;
+    }
     const convertedColor = convertColor(color);
     return { darkColor: convertedColor, lightColor: convertedColor };
   }

package/src/utils/NitroImage.ts

@@ -96,11 +96,7 @@ function convert(image?: AutoImage): NitroImage | undefined {
   }
 
   if (image.type === 'glyph') {
-    const {
-      color = { darkColor: 'white', lightColor: 'black' },
-      fontScale,
-      backgroundColor = 'transparent',
-    } = image;
+    const { color = 'default', fontScale, backgroundColor = 'transparent' } = image;
 
     return {
       glyph: resolveGlyph(image),

package/src/utils/NitroManeuver.ts

@@ -71,10 +71,7 @@ function convertManeuverImage(image?: ManeuverImage): NitroImage | undefined {
   }
 
   if (image.type === 'glyph') {
-    const color =
-      typeof image.color === 'string'
-        ? image.color
-        : (image.color ?? { darkColor: 'white', lightColor: 'black' });
+    const color = typeof image.color === 'string' ? image.color : (image.color ?? 'default');
     return NitroImageUtil.convert({
       ...image,
       color: color,