@lightningtv/solid 3.0.0-8 → 3.0.0-9

package/src/primitives/announcer/speech.ts

@@ -1,4 +1,8 @@
-type CoreSpeechType = string | (() => SpeechType) | SpeechType[];
+type CoreSpeechType =
+  | string
+  | (() => SpeechType)
+  | SpeechType[]
+  | SpeechSynthesisUtterance;
 export type SpeechType = CoreSpeechType | Promise<CoreSpeechType>;
 
 export interface SeriesResult {
@@ -87,11 +91,6 @@ function speakSeries(
     Array.isArray(series) ? series : [series],
   );
   const nestedSeriesResults: SeriesResult[] = [];
-  /*
-    We hold this array of SpeechSynthesisUtterances in order to prevent them from being
-    garbage collected prematurely on STB hardware which can cause the 'onend' events of
-    utterances to not fire consistently.
-  */
   const utterances: SpeechSynthesisUtterance[] = [];
   let active: boolean = true;
 
@@ -100,24 +99,61 @@ function speakSeries(
       while (active && remainingPhrases.length) {
         const phrase = await Promise.resolve(remainingPhrases.shift());
         if (!active) {
-          // Exit
-          // Need to check this after the await in case it was cancelled in between
-          break;
-        } else if (typeof phrase === 'string' && phrase.includes('PAUSE-')) {
-          // Pause it
-          let pause = Number(phrase.split('PAUSE-')[1]) * 1000;
-          if (isNaN(pause)) {
-            pause = 0;
+          break; // Exit if canceled
+        }
+
+        if (typeof phrase === 'string' && phrase.includes('PAUSE-')) {
+          // Handle pauses
+          const pause = Number(phrase.split('PAUSE-')[1]) * 1000;
+          if (!isNaN(pause)) {
+            await delay(pause);
+          }
+        } else if (typeof phrase === 'string') {
+          if (!phrase) {
+            continue; // Skip empty strings
           }
-          await delay(pause);
-        } else if (typeof phrase === 'string' && phrase.length) {
-          // Speak it
+          // Handle regular strings with retry logic
           const totalRetries = 3;
           let retriesLeft = totalRetries;
+
           while (active && retriesLeft > 0) {
             try {
               await speak(phrase, utterances, lang, voice);
-              retriesLeft = 0;
+              retriesLeft = 0; // Exit retry loop on success
+            } catch (e) {
+              if (e instanceof SpeechSynthesisErrorEvent) {
+                if (e.error === 'network') {
+                  retriesLeft--;
+                  console.warn(
+                    `Speech synthesis network error. Retries left: ${retriesLeft}`,
+                  );
+                  await delay(500 * (totalRetries - retriesLeft));
+                } else if (
+                  e.error === 'canceled' ||
+                  e.error === 'interrupted'
+                ) {
+                  // Cancel or interrupt error (ignore)
+                  retriesLeft = 0;
+                } else {
+                  throw new Error(`SpeechSynthesisErrorEvent: ${e.error}`);
+                }
+              } else {
+                throw e;
+              }
+            }
+          }
+        } else if (phrase instanceof SpeechSynthesisUtterance) {
+          // Handle SpeechSynthesisUtterance objects with retry logic
+          const totalRetries = 3;
+          let retriesLeft = totalRetries;
+          const text = phrase.text;
+          const objectLang = phrase?.lang;
+          const objectVoice = phrase?.voice;
+
+          while (active && retriesLeft > 0) {
+            try {
+              await speak(text, utterances, objectLang, objectVoice?.name);
+              retriesLeft = 0; // Exit retry loop on success
             } catch (e) {
               if (e instanceof SpeechSynthesisErrorEvent) {
                 if (e.error === 'network') {
@@ -141,11 +177,12 @@ function speakSeries(
             }
           }
         } else if (typeof phrase === 'function') {
+          // Handle functions
           const seriesResult = speakSeries(phrase(), lang, voice, false);
           nestedSeriesResults.push(seriesResult);
           await seriesResult.series;
         } else if (Array.isArray(phrase)) {
-          // Speak it (recursively)
+          // Handle nested arrays
           const seriesResult = speakSeries(phrase, lang, voice, false);
           nestedSeriesResults.push(seriesResult);
           await seriesResult.series;
@@ -155,6 +192,7 @@ function speakSeries(
       active = false;
     }
   })();
+
   return {
     series: seriesChain,
     get active() {
@@ -168,16 +206,15 @@ function speakSeries(
         return;
       }
       if (root) {
-        synth.cancel();
+        synth.cancel(); // Cancel all ongoing speech
       }
-      nestedSeriesResults.forEach((nestedSeriesResults) => {
-        nestedSeriesResults.cancel();
+      nestedSeriesResults.forEach((nestedSeriesResult) => {
+        nestedSeriesResult.cancel();
       });
       active = false;
     },
   };
 }
-
 let currentSeries: SeriesResult | undefined;
 export default function (
   toSpeak: SpeechType,

package/src/primitives/index.ts

@@ -12,7 +12,8 @@ export * from './Grid.jsx';
 export * from './FPSCounter.jsx';
 export * from './FadeInOut.jsx';
 export * from './createFocusStack.jsx';
-export * from './marquee.jsx';
+export * from './Marquee.jsx';
+export * from './useHold.js';
 export { withScrolling } from './utils/withScrolling.js';
 export {
   type AnyFunction,

package/src/primitives/types.ts

@@ -1,5 +1,6 @@
 import type { ElementNode, NodeProps, NodeStyles } from '@lightningtv/solid';
 import type { KeyHandler } from '@lightningtv/core/focusManager';
+
 export type OnSelectedChanged = (
   this: NavigableElement,
   selectedIndex: number,
@@ -7,6 +8,7 @@ export type OnSelectedChanged = (
   active: ElementNode,
   lastSelectedIndex?: number,
 ) => void;
+
 export interface NavigableProps extends NodeProps {
   /** function to be called when the selected of the component changes */
   onSelectedChanged?: OnSelectedChanged;
@@ -40,6 +42,13 @@ export interface NavigableProps extends NodeProps {
    * Wrap the row so active goes back to the beginning of the row
    */
   wrap?: boolean;
+
+  /** function to be called when scrolled */
+  onScrolled?: (
+    elm: NavigableElement,
+    offset: number,
+    isInitial: boolean,
+  ) => void;
 }
 
 // @ts-expect-error animationSettings is not identical - weird

package/src/primitives/useHold.ts

@@ -0,0 +1,69 @@
+import { createMemo } from 'solid-js';
+
+export type UseHoldProps = {
+  onHold: () => void;
+  onEnter: () => void;
+  onRelease?: () => void;
+  holdThreshold?: number;
+  performOnEnterImmediately?: boolean;
+};
+
+/**
+ * @example
+ * const [holdRight, releaseRight] = useHold({
+ *   onHold: handleHoldRight,
+ *   onEnter: handleOnRight,
+ *   onRelease: handleReleaseHold,
+ *   holdThreshold: 200,
+ *   performOnEnterImmediately: true
+ * });
+ *
+ * <View
+ *   onRight={holdRight}
+ *   onRightRelease={releaseRight}
+ * />
+ *
+ * @param {UseHoldProps} props - The properties for configuring the hold behavior.
+ * @returns {[() => boolean, () => boolean]} A tuple containing `startHold` and `releaseHold` functions.
+ */
+
+export function useHold(props: UseHoldProps) {
+  const holdThreshold = createMemo(() => props.holdThreshold ?? 500);
+  const performOnEnterImmediately = createMemo(
+    () => props.performOnEnterImmediately ?? false,
+  );
+
+  let holdTimeout = -1;
+  let wasHeld = false;
+
+  const startHold = () => {
+    if (holdTimeout === -1) {
+      if (performOnEnterImmediately()) {
+        props.onEnter();
+      }
+      holdTimeout = setTimeout(() => {
+        wasHeld = true;
+        props.onHold();
+      }, holdThreshold()) as unknown as number;
+    }
+    return true;
+  };
+
+  const releaseHold = () => {
+    if (holdTimeout !== -1) {
+      clearTimeout(holdTimeout);
+      holdTimeout = -1;
+      if (!wasHeld) {
+        if (!performOnEnterImmediately()) props.onEnter();
+        return;
+      }
+      props.onRelease?.();
+      wasHeld = false;
+    }
+    return true;
+  };
+
+  return [startHold, releaseHold];
+}
+
+export default useHold;

package/src/primitives/utils/withScrolling.ts

@@ -11,8 +11,14 @@ export interface ScrollableElement extends ElementNode {
   selected: number;
   offset?: number;
   endOffset?: number;
+  onScrolled?: (
+    elm: ScrollableElement,
+    offset: number,
+    isInitial: boolean,
+  ) => void;
   _targetPosition?: number;
   _screenOffset?: number;
+  _initialPosition?: number;
 }
 
 // From the renderer, not exported
@@ -48,6 +54,10 @@ export function withScrolling(isRow: boolean) {
     )
       return;
 
+    if (componentRef._initialPosition === undefined) {
+      componentRef._initialPosition = componentRef[axis];
+    }
+
     const lng = componentRef.lng as INode;
     const screenSize = isRow ? lng.stage.root.width : lng.stage.root.height;
     // Determine if movement is incremental or decremental
@@ -157,6 +167,11 @@ export function withScrolling(isRow: boolean) {
 
     // Update position if it has changed
     if (componentRef[axis] !== nextPosition) {
+      if (componentRef.onScrolled) {
+        const isInitial = nextPosition === componentRef._initialPosition;
+        componentRef.onScrolled(componentRef, nextPosition, isInitial);
+      }
+
       componentRef[axis] = nextPosition;
       // Store the new position to keep track during animations
       componentRef._targetPosition = nextPosition;