@applicaster/zapp-react-dom-app 16.0.0-rc.10 → 16.0.0-rc.101

package/App/InteractionManager/index.tsx

@@ -204,7 +204,7 @@ class InteractionManagerClass extends React.Component<Props, State> {
   }
 
   componentWillUnmount() {
-    window.removeEventListener("keydown", this.onKeyDownListener);
+    window.removeEventListener("keydown", this.onKeyDownListener, true);
     window.removeEventListener("keyup", this.onKeyUp);
     document.removeEventListener("wheel", this.onScrollListener);
 
@@ -422,7 +422,17 @@ class InteractionManagerClass extends React.Component<Props, State> {
 
     const action = backToTopAction();
 
-    switch (displayState) {
+    const effectiveDisplayState = this.getEffectiveDisplayState();
+
+    // TEMP(native-controls): remove after device verification
+    if (effectiveDisplayState !== displayState) {
+      log_debug("[NativeControls] Back handled as PLAYER", {
+        displayState,
+        action,
+      });
+    }
+
+    switch (effectiveDisplayState) {
       case DISPLAY_STATES.DEFAULT:
         if (action === "PLATFORM_TO_BACKGROUND") {
           log_info(action);
@@ -522,8 +532,42 @@ class InteractionManagerClass extends React.Component<Props, State> {
     this.onBackPress(event);
   }
 
+  // True only while the active (primary) player renders its own controls.
+  isNativePlayerControlsEnabled = () =>
+    !!playerManager.getInstanceController?.()?.supportsNativeControls?.();
+
+  // PLAYER/HUD are set by QuickBrick's TV transport controls, which are not
+  // mounted when the player renders native controls — the state would stay
+  // DEFAULT and keys would reach the screen behind the player (Enter re-opens it).
+  // The play-next overlay is the exception: it is QuickBrick UI, so the real
+  // state applies and Enter presses the focused overlay button.
+  getEffectiveDisplayState = () =>
+    this.isNativePlayerControlsEnabled() && !this.isPlayNextOverlayVisible()
+      ? DISPLAY_STATES.PLAYER
+      : this.props.displayState;
+
+  // True when the player closed something of its own instead.
+  playerConsumesBack = () =>
+    !!playerManager.getInstanceController?.()?.handlesBackKey?.();
+
+  // While the play-next overlay is up it owns the remote: its buttons are
+  // QuickBrick focusables, so the keys must not go to the player's own controls.
+  isPlayNextOverlayVisible = () =>
+    !!this.props.navigator?.getPlayNextOverlay?.();
+
+  shouldDeferPlaybackNavigationToNativeControls = (event: KeyboardEvent) => {
+    return (
+      this.isNativePlayerControlsEnabled() &&
+      !this.isPlayNextOverlayVisible() &&
+      (keyCode(event).matchesAny(...ARROW_KEYS) ||
+        keyCode(event).matches(KEYS.Enter) ||
+        (__DEV__ && keyCode(event).matches(KEYS.X)))
+    );
+  };
+
   onKeyDown(event) {
-    const { displayState, setDisplayState, navigator, xray } = this.props;
+    const { setDisplayState, navigator, xray } = this.props;
+    const displayState = this.getEffectiveDisplayState();
     const { isDialogVisible } = confirmationDialogStore.getState();
     const { isKeyboardVisible } = this.state;
 
@@ -541,6 +585,12 @@ class InteractionManagerClass extends React.Component<Props, State> {
     }
 
     if (keyCode(event).matchesAny(KEYS.Back, KEYS.Escape, KEYS.EscapeDevice)) {
+      // A player with native controls can have something of its own open that
+      // Back should close first (e.g. an ad click-through overlay).
+      if (this.isNativePlayerControlsEnabled() && this.playerConsumesBack()) {
+        return;
+      }
+
       this.onBackPress(event);
 
       return;
@@ -553,6 +603,21 @@ class InteractionManagerClass extends React.Component<Props, State> {
     // Only handle repeat events for arrow keys
     if (event.repeat && !keyCode(event).matchesAny(...ARROW_KEYS)) return;
 
+    if (
+      !isDialogVisible &&
+      this.shouldDeferPlaybackNavigationToNativeControls(event)
+    ) {
+      // The player's own spatial navigation handles these keys.
+      // TEMP(native-controls): remove after device verification
+      log_debug("[NativeControls] key deferred to player", {
+        key: event.key,
+        displayState,
+        activeElement: document.activeElement?.className,
+      });
+
+      return;
+    }
+
     /**
      When the player is displayed, we listen to Native Play / Pause / Stop
      buttons. Any other key press will display the transport controls
@@ -569,7 +634,7 @@ class InteractionManagerClass extends React.Component<Props, State> {
         const { playing } = playerManager.getState() || {};
 
         if (!playing) {
-          return playerManager.togglePlayPause();
+          return playerManager.getInstanceController()?.togglePlayPause();
         }
       }
 

package/App/Loader/utils/const.js

@@ -64,6 +64,10 @@ export const PLATFORMS = {
   android: "Android",
   mobile: "Mobile",
   vizio: "VIZIO",
+  vidaa: "VIDAA",
+  // VIDAA U3 and earlier (2019 and earlier) carry no "VIDAA" token at all —
+  // "Hisense" is the only signal on those models. See isVidaaPlatform().
+  hisense: "Hisense",
   smartcast: "SmartCast",
   conjure: "Conjure",
 };
@@ -74,14 +78,42 @@ export const PLATFORMS = {
 
 /**
  * Simple way of identifying if we have access to the tizen APIs
+ *
+ * NOTE: evaluated once, when this module is first imported. The native API
+ * scripts are injected asynchronously by loader.js, so this can be `false`
+ * simply because the bundle executed first. Prefer `hasTizenAPIs()` for
+ * runtime checks; this constant is retained for the DEFAULT values below,
+ * which are themselves import-time fallbacks.
  */
 export const hasTizen = typeof window?.tizen !== "undefined";
 
 /**
  * Simple way of identifying if we have access to the webOS
+ *
+ * NOTE: same import-time caveat as `hasTizen` — prefer `hasWebOSAPIs()`.
  */
 export const hasWebOS = typeof window?.webOS !== "undefined";
 
+/**
+ * Checks, at call time, whether the Tizen APIs are available.
+ *
+ * loader.js injects `$WEBAPIS/webapis/webapis.js` via a dynamically-created
+ * <script>, which is async by default, so `window.tizen` may not exist yet when
+ * this module is imported. Checking on each call avoids latching a stale
+ * `false` for the lifetime of the app.
+ *
+ * @returns {boolean} True if the Tizen APIs are available.
+ */
+export const hasTizenAPIs = () => typeof window?.tizen !== "undefined";
+
+/**
+ * Checks, at call time, whether the webOS APIs are available.
+ * See `hasTizenAPIs()` for why this is a function rather than a constant.
+ *
+ * @returns {boolean} True if the webOS APIs are available.
+ */
+export const hasWebOSAPIs = () => typeof window?.webOS !== "undefined";
+
 /**
  * Simple way of identifying if we are on a web based platform
  */

package/App/Loader/utils/platform.js

@@ -3,17 +3,11 @@
 /* eslint-disable no-console */
 
 import { Platform } from "react-native";
-import {
-  DEFAULT,
-  desiredKeysMap,
-  hasTizen,
-  hasWebOS,
-  PLATFORMS,
-} from "./const";
+import { desiredKeysMap, hasTizenAPIs, hasWebOSAPIs, PLATFORMS } from "./const";
 
 /**
  * @typedef {"tv" | "web" | "other"} DeviceType
- * @typedef {"samsung_tv" | "lg_tv" | unknown} CustomPlatformTypes
+ * @typedef {"samsung_tv" | "lg_tv" | "vidaa" | unknown} CustomPlatformTypes
  */
 
 /**
@@ -27,7 +21,7 @@ export const getUserAgent = () =>
  * Checks if the device is HD (1280 width).
  * @returns {boolean} True if the device is HD, false otherwise.
  */
-export const isHD = () => window.innerWidth === 1280;
+export const isHD = () => window?.innerWidth === 1280;
 
 /**
  * Checks if the platform is LG.
@@ -40,7 +34,7 @@ export const isLgPlatform = () => {
     return false;
   }
 
-  return hasWebOS || userAgent.includes(PLATFORMS.webos);
+  return hasWebOSAPIs() || userAgent.includes(PLATFORMS.webos);
 };
 
 /**
@@ -55,7 +49,7 @@ export const isSamsungPlatform = () => {
   }
 
   return (
-    hasTizen ||
+    hasTizenAPIs() ||
     userAgent.includes(PLATFORMS.samsung) ||
     userAgent.includes(PLATFORMS.tizen)
   );
@@ -68,6 +62,10 @@ export const isSamsungPlatform = () => {
 export const isVizioPlatform = () => {
   const userAgent = getUserAgent();
 
+  if (!userAgent) {
+    return false;
+  }
+
   return (
     userAgent.includes(PLATFORMS.vizio) ||
     userAgent.includes(PLATFORMS.smartcast) ||
@@ -75,17 +73,241 @@ export const isVizioPlatform = () => {
   );
 };
 
+/**
+ * Checks if the platform is VIDAA.
+ *
+ * Two tokens are needed because the userAgent format changed with VIDAA U4:
+ * - 2020 and later (U4/U5/U6/U7): always carries a "VIDAA" token, e.g.
+ *   `Model/Hisense-MT9602 VIDAA/5.0(Hisense;SmartTV;50A53FSV;...)`
+ * - 2019 and earlier (U3 and prior): carries NO "VIDAA" token at all — the only
+ *   signal is "Hisense", e.g. `Model/Hisense-MSD6586 (Hisense;HE50N3050UWTS;...)`
+ *
+ * Matching "VIDAA" alone silently misses every U3-and-earlier device, which the
+ * VIDAA JS SDK still supports (getDeviceID/getBrand/config are all U3U4U5+).
+ *
+ * Caveat: "Hisense" also appears in the userAgent of Hisense-branded Android TV
+ * models, which are not VIDAA. That is tolerable here because this is only
+ * consulted on a VIDAA-targeted build (see getDeviceType), but it is why the
+ * vendor docs warn against using "Hisense" as a general-purpose signal. A
+ * stricter check would test for the native `Hisense_GetDeviceID` global, which
+ * VIDAA exposes from U3 onwards and Android TV does not.
+ *
+ * @see https://partner-doc.vidaa.com/vdocs/development/open-capacity.html
+ * @returns {boolean} True if the platform is VIDAA, false otherwise.
+ */
+export const isVidaaPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  return (
+    userAgent.includes(PLATFORMS.vidaa) || userAgent.includes(PLATFORMS.hisense)
+  );
+};
+
 /**
  * Checks if the Vizio APIs are available.
  * @returns {boolean} True if the Vizio APIs are available, false otherwise.
  */
 export const hasVizioAPIs = () => {
   return (
-    typeof window.VIZIO !== "undefined" &&
+    typeof window?.VIZIO !== "undefined" &&
     window?.applicaster?.vizioLibraryDidLoad
   );
 };
 
+/**
+ * Checks if the VIDAA JS SDK has finished loading.
+ * @returns {boolean} True if the `vidaatv` object is available.
+ */
+export const hasVidaaAPIs = () => typeof window?.vidaatv !== "undefined";
+
+/** How long to wait for a native device API callback before giving up, in ms. */
+const NATIVE_API_TIMEOUT_MS = 3000;
+
+/**
+ * Wraps a promise so that it *always* settles, and always resolves.
+ *
+ * The native device APIs are callback-based and wrapped in promises that can
+ * fail in two ways this guards against:
+ *
+ * 1. **Rejection.** Device info and connection info are requested together with
+ *    `Promise.all`, which rejects as a whole on the first failure — so a routine
+ *    "no network" error from the connection lookup would discard the model and
+ *    OS version that were retrieved successfully.
+ * 2. **Never settling.** `webOS.deviceInfo(cb)`, `tizen.systeminfo(cb)` and
+ *    `VIZIO.getFirmwareVersion(cb)` resolve only from their callbacks. If a
+ *    callback never fires the promise hangs forever, and because `getDeviceData`
+ *    is awaited during startup, app boot hangs with it.
+ *
+ * @param {Promise} promise The promise to guard.
+ * @param {object} options
+ * @param {string} options.label Name used in warnings.
+ * @param {number} [options.timeout=NATIVE_API_TIMEOUT_MS] Milliseconds to wait.
+ * @param {*} [options.fallback=null] Value to resolve with on failure/timeout.
+ * @returns {Promise<*>} Resolves with the value, or `fallback`.
+ */
+const settleWithin = (
+  promise,
+  { label, timeout = NATIVE_API_TIMEOUT_MS, fallback = null } = {}
+) => {
+  return new Promise((resolve) => {
+    let settled = false;
+
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      clearTimeout(timeoutId);
+      resolve(value);
+    };
+
+    const timeoutId = setTimeout(() => {
+      console.warn(`${label}: timed out after ${timeout}ms`);
+      finish(fallback);
+    }, timeout);
+
+    Promise.resolve(promise)
+      .then(finish)
+      .catch((error) => {
+        console.warn(`${label}: failed`, error);
+        finish(fallback);
+      });
+  });
+};
+
+/** How long to wait for the VIDAA SDK before giving up, in ms. */
+const VIDAA_SDK_TIMEOUT_MS = 3000;
+
+/** How often to re-check for the VIDAA SDK while waiting, in ms. */
+const VIDAA_SDK_POLL_MS = 50;
+
+/**
+ * The value the VIDAA SDK returns for APIs the current platform version does
+ * not implement, per the vendor docs ("For features Not Supported by the
+ * platform, the interface returns `Not Supported`"). Treated as absent.
+ */
+const VIDAA_NOT_SUPPORTED = "Not Supported";
+
+/**
+ * Waits for the VIDAA JS SDK to become available on `window`.
+ *
+ * The SDK is injected by loader.js as a dynamically-created <script>, which is
+ * async by default and fetched from the VIDAA CDN. The app bundle is served
+ * locally and can therefore boot before that request completes, so reading
+ * `window.vidaatv` directly at startup is a race. This resolves as soon as the
+ * SDK appears, or with `null` once the timeout elapses.
+ *
+ * Resolves rather than rejects on timeout so a missing SDK degrades to partial
+ * device data instead of failing the whole `getDeviceData` call.
+ *
+ * @param {number} [timeout=VIDAA_SDK_TIMEOUT_MS] Milliseconds to wait.
+ * @returns {Promise<object|null>} The `vidaatv` object, or null if it never arrived.
+ */
+export const waitForVidaaAPIs = (timeout = VIDAA_SDK_TIMEOUT_MS) => {
+  return new Promise((resolve) => {
+    if (hasVidaaAPIs()) {
+      resolve(window.vidaatv);
+
+      return;
+    }
+
+    const startedAt = Date.now();
+
+    const intervalId = setInterval(() => {
+      if (hasVidaaAPIs()) {
+        clearInterval(intervalId);
+        resolve(window.vidaatv);
+
+        return;
+      }
+
+      if (Date.now() - startedAt >= timeout) {
+        clearInterval(intervalId);
+
+        console.warn(
+          `waitForVidaaAPIs: VIDAA SDK did not load within ${timeout}ms`
+        );
+
+        resolve(null);
+      }
+    }, VIDAA_SDK_POLL_MS);
+  });
+};
+
+/**
+ * Reads a single value from the VIDAA SDK, tolerating APIs that the current
+ * platform version does not implement.
+ *
+ * Every accessor is optional: older platforms omit the method entirely, and
+ * supported-but-unavailable values come back as the string "Not Supported".
+ *
+ * @param {object} sdk The `vidaatv` object.
+ * @param {string} method The accessor name, e.g. "getModelName".
+ * @returns {string|null} The value, or null when unavailable.
+ */
+const readVidaaValue = (sdk, method) => {
+  try {
+    if (typeof sdk?.[method] !== "function") {
+      return null;
+    }
+
+    const value = sdk[method]();
+
+    return value && value !== VIDAA_NOT_SUPPORTED ? value : null;
+  } catch (error) {
+    console.warn(`readVidaaValue: ${method} threw`, error);
+
+    return null;
+  }
+};
+
+/**
+ * Gets device info from the VIDAA JS SDK.
+ *
+ * Field availability varies by VIDAA version, so each value is read
+ * defensively and omitted when unavailable:
+ * - getBrand / getModelName / getFirmWareVersion / getCountryCode are U3+
+ * - getOSVersion / getNetType are U4+, hence the firmware fallback for
+ *   osVersion so pre-2020 models still report something
+ *
+ * @returns {Promise<object|null>} Device info, or null if the SDK never loaded.
+ */
+export const getVidaaInfo = async () => {
+  const sdk = await waitForVidaaAPIs();
+
+  if (!sdk) {
+    return null;
+  }
+
+  const modelName = readVidaaValue(sdk, "getModelName");
+  const brand = readVidaaValue(sdk, "getBrand");
+  const networkType = readVidaaValue(sdk, "getNetType");
+  const countryCode = readVidaaValue(sdk, "getCountryCode");
+
+  // getOSVersion is U4+; fall back to the firmware version, which is U3+.
+  const osVersion =
+    readVidaaValue(sdk, "getOSVersion") ||
+    readVidaaValue(sdk, "getFirmWareVersion");
+
+  // Human-readable name for the `deviceName` context key, e.g.
+  // "Hisense 50A53FSV". Falls back to whichever half is available.
+  const deviceName = [brand, modelName].filter(Boolean).join(" ");
+
+  return {
+    ...(modelName ? { modelName } : {}),
+    ...(brand ? { deviceMake: brand } : {}),
+    ...(deviceName ? { deviceName } : {}),
+    ...(osVersion ? { osVersion } : {}),
+    ...(networkType ? { networkType } : {}),
+    ...(countryCode ? { countryCode } : {}),
+  };
+};
+
 /**
  * Determines the device type based on the platform.
  * @returns {DeviceType} The device type ("tv", "web", or "other").
@@ -99,6 +321,10 @@ export const getDeviceType = () => {
       return isSamsungPlatform() ? "tv" : "web";
     case "lg_tv":
       return isLgPlatform() ? "tv" : "web";
+    case "vizio":
+      return isVizioPlatform() ? "tv" : "web";
+    case "vidaa":
+      return isVidaaPlatform() ? "tv" : "web";
     default:
       return "other";
   }
@@ -151,7 +377,7 @@ export const getWebOSConnectionInfo = () => {
  */
 export const getTizenConnectionInfo = () => {
   return new Promise((resolve, reject) => {
-    if (!isSamsungPlatform) {
+    if (!isSamsungPlatform()) {
       resolve(null);
 
       return;
@@ -175,6 +401,36 @@ export const getTizenConnectionInfo = () => {
   });
 };
 
+/**
+ * Retrieves the firmware version from the Vizio companion library.
+ *
+ * `VIZIO.getFirmwareVersion` is callback-based. It was previously called
+ * without being awaited, assigning onto `deviceData` after `getDeviceData` had
+ * already returned — by which point the caller had spread the object into
+ * session storage, so the value was silently dropped whenever the callback did
+ * not fire synchronously. Wrapping it in a promise lets it be awaited like
+ * every other platform's device info.
+ *
+ * @returns {Promise<string|null>} The firmware version, or null if unavailable.
+ */
+export const getVizioFirmwareVersion = () => {
+  return new Promise((resolve, reject) => {
+    if (!hasVizioAPIs()) {
+      resolve(null);
+
+      return;
+    }
+
+    try {
+      window.VIZIO.getFirmwareVersion((firmwareVersion) => {
+        resolve(firmwareVersion);
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
 /**
  * Gets all of the webOS device info available to us via webOS.deviceInfo
  */
@@ -190,7 +446,12 @@ export const getWebOSInfo = () => {
       if (info) {
         resolve({
           ...info,
-          name: `${info.modelName} - ${info.version}`,
+          // `deviceName` is a persisted context key; the previous `name` was
+          // absent from desiredKeysMap, so it was computed and dropped. Format
+          // is "<make> <model>", matching Samsung/Vizio/VIDAA. The old string
+          // was `${info.modelName} - ${info.version}`, which omitted the make
+          // and embedded a version already reported as osVersion.
+          deviceName: `LG ${info.modelName}`,
           osVersion: info.sdkVersion, // info.sdkVersion is the OS version, info.version is software version
         });
       } else {
@@ -217,16 +478,22 @@ export const getTizenInfo = () => {
         "http://tizen.org/system/model_name"
       );
 
-      const name = `${DEFAULT.make} ${modelName}`;
+      // Previously `${DEFAULT.make} ${modelName}` — DEFAULT has no `make` key
+      // (it is `deviceMake`), so this interpolated the literal string
+      // "undefined". It went unnoticed because the value was named `name`,
+      // which is absent from desiredKeysMap and therefore never persisted.
+      const deviceName = `Samsung ${modelName}`;
 
       const osVersion = tizen.systeminfo.getCapability(
         "http://tizen.org/feature/platform.version"
       );
 
-      if (modelName && name && osVersion) {
+      // `deviceName` is derived from modelName, so checking it here would be
+      // redundant — it is truthy whenever modelName is.
+      if (modelName && osVersion) {
         resolve({
           modelName,
-          name,
+          deviceName,
           osVersion,
         });
       } else {
@@ -265,9 +532,13 @@ export const getDeviceData = async () => {
     };
 
     if (isLgPlatform()) {
+      // Guarded individually so a failure in one lookup does not discard the
+      // other — see settleWithin.
       const [webOSInfo, webOSConnectionInfo] = await Promise.all([
-        getWebOSInfo(),
-        getWebOSConnectionInfo(),
+        settleWithin(getWebOSInfo(), { label: "getWebOSInfo" }),
+        settleWithin(getWebOSConnectionInfo(), {
+          label: "getWebOSConnectionInfo",
+        }),
       ]);
 
       deviceData = {
@@ -280,8 +551,10 @@ export const getDeviceData = async () => {
       };
     } else if (isSamsungPlatform()) {
       const [tizenInfo, tizenConnectionInfo] = await Promise.all([
-        getTizenInfo(),
-        getTizenConnectionInfo(),
+        settleWithin(getTizenInfo(), { label: "getTizenInfo" }),
+        settleWithin(getTizenConnectionInfo(), {
+          label: "getTizenConnectionInfo",
+        }),
       ]);
 
       deviceData = {
@@ -297,17 +570,39 @@ export const getDeviceData = async () => {
         ...deviceData,
         platform: "vizio",
         deviceMake: "Vizio",
-        deviceType: "tv",
+        deviceType: getDeviceType(),
         ...deviceDimensions,
       };
 
       if (hasVizioAPIs()) {
-        window.VIZIO.getFirmwareVersion(function (firmwareVersion) {
-          deviceData.osVersion = firmwareVersion;
+        const firmwareVersion = await settleWithin(getVizioFirmwareVersion(), {
+          label: "getVizioFirmwareVersion",
         });
 
+        if (firmwareVersion) {
+          deviceData.osVersion = firmwareVersion;
+        }
+
         deviceData.deviceModel = window.VIZIO.deviceModel;
+
+        if (deviceData.deviceModel) {
+          deviceData.deviceName = `Vizio ${deviceData.deviceModel}`;
+        }
       }
+    } else if (isVidaaPlatform()) {
+      // Waits for the VIDAA SDK, which loader.js loads asynchronously from the
+      // VIDAA CDN. Resolves to null on timeout, leaving the static fields below.
+      const vidaaInfo = await getVidaaInfo();
+
+      deviceData = {
+        ...vidaaInfo,
+        platform: "vidaa",
+        // Brand is read from the SDK rather than hardcoded: VIDAA ships on
+        // OEM sets beyond Hisense, so getBrand() is the accurate source.
+        deviceMake: vidaaInfo?.deviceMake || "Hisense",
+        deviceType: getDeviceType(),
+        ...deviceDimensions,
+      };
     }
 
     return deviceData;
@@ -318,6 +613,10 @@ export const getDeviceData = async () => {
       error
     );
 
-    return null;
+    // Returns an empty object rather than null: the caller
+    // (loadSessionStorageData) does `delete deviceData.sdkVersion` on the
+    // result, which throws a TypeError on null and turns a handled error into
+    // an unhandled one during startup.
+    return {};
   }
 };

package/Polyfills/AppLoaderBridge/utils/enums.ts

@@ -9,4 +9,5 @@ export enum STORE_PLATFORM {
   lg = "lg_content_store",
   samsung = "samsung_app_store",
   vizio = "vizio_app_store",
+  vidaa = "vidaa_app_store",
 }

package/Polyfills/Storage/__tests__/StorageMocks.js

@@ -26,7 +26,7 @@ export function StorageMock() {
 
     delete this[key];
 
-    return true;
+    // Return undefined like the real API; a truthy return would re-mask the bug.
   };
 
   storage.getItem = (key) => {

package/Polyfills/Storage/index.js

@@ -155,7 +155,11 @@ export function getStorageModule(type) {
   function removeItem(key, namespace = DEFAULT_NAMESPACE) {
     const keyName = applyNamespaceToKeyName(key, namespace);
 
-    return tryAndResolve(() => Storage.callMethod("removeItem", keyName));
+    return tryAndResolve(() => {
+      Storage.callMethod("removeItem", keyName);
+
+      return true;
+    });
   }
 
   /**

package/Polyfills/index.js

@@ -15,6 +15,7 @@ import "@webcomponents/webcomponentsjs";
 const PLATFORM_KEYS = {
   samsung: "samsung_tv",
   lg: "lg_tv",
+  vidaa: "vidaa",
   web: "web",
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-dom-app",
-  "version": "16.0.0-rc.10",
+  "version": "16.0.0-rc.101",
   "description": "Zapp App Component for Applicaster's Quick Brick React Native App",
   "main": "index.js",
   "scripts": {
@@ -22,11 +22,11 @@
   },
   "homepage": "https://github.com/applicaster/zapp-react-dom-app#readme",
   "dependencies": {
-    "@applicaster/zapp-react-dom-ui-components": "16.0.0-rc.10",
-    "@applicaster/zapp-react-native-bridge": "16.0.0-rc.10",
-    "@applicaster/zapp-react-native-redux": "16.0.0-rc.10",
-    "@applicaster/zapp-react-native-ui-components": "16.0.0-rc.10",
-    "@applicaster/zapp-react-native-utils": "16.0.0-rc.10",
+    "@applicaster/zapp-react-dom-ui-components": "16.0.0-rc.101",
+    "@applicaster/zapp-react-native-bridge": "16.0.0-rc.101",
+    "@applicaster/zapp-react-native-redux": "16.0.0-rc.101",
+    "@applicaster/zapp-react-native-ui-components": "16.0.0-rc.101",
+    "@applicaster/zapp-react-native-utils": "16.0.0-rc.101",
     "abortcontroller-polyfill": "^1.7.5",
     "typeface-montserrat": "^0.0.54",
     "video.js": "7.14.3",