heartraite 1.0.213 → 1.0.215

package/dist/enum/notification.enum.d.ts

@@ -1,5 +1,6 @@
 export declare enum NotificationSetting {
     NEW_MATCH = "new-match",
     NEW_LIKE = "new-like",
-    NEW_MESSAGE = "new-message"
+    NEW_MESSAGE = "new-message",
+    MATCH_SUGGESTION = "match-suggestion"
 }

package/dist/enum/notification.enum.js

@@ -6,4 +6,5 @@ var NotificationSetting;
     NotificationSetting["NEW_MATCH"] = "new-match";
     NotificationSetting["NEW_LIKE"] = "new-like";
     NotificationSetting["NEW_MESSAGE"] = "new-message";
+    NotificationSetting["MATCH_SUGGESTION"] = "match-suggestion";
 })(NotificationSetting || (exports.NotificationSetting = NotificationSetting = {}));

package/dist/hooks/useTypewriter.d.ts

@@ -8,5 +8,6 @@ export declare const useTypewriter: ({ text, typingSpeed, initialDelay, blinking
     displayedText: string;
     showDot: boolean;
     isComplete: boolean;
+    revealAll: () => void;
 };
 export {};

package/dist/hooks/useTypewriter.js

@@ -6,56 +6,63 @@ const useTypewriter = ({ text, typingSpeed = 50, initialDelay = 1000, blinkingSp
     const [isComplete, setIsComplete] = (0, react_1.useState)(false);
     const [displayedText, setDisplayedText] = (0, react_1.useState)("");
     const [showDot, setShowDot] = (0, react_1.useState)(false);
+    const timersRef = (0, react_1.useRef)({ blinking: null, timeouts: new Set() });
+    const clearTimers = (0, react_1.useCallback)(() => {
+        const timers = timersRef.current;
+        if (timers.blinking)
+            clearInterval(timers.blinking);
+        timers.blinking = null;
+        timers.timeouts.forEach(clearTimeout);
+        timers.timeouts.clear();
+    }, []);
     (0, react_1.useEffect)(() => {
         if (!text || text.length === 0) {
-            setDisplayedText(""); // No text to display
-            setIsComplete(true); // Mark typing as complete immediately
-            setShowDot(false); // No blinking dot for empty text
-            return; // Exit early if text is empty
+            setDisplayedText("");
+            setIsComplete(true);
+            setShowDot(false);
+            return;
         }
-        let blinkingInterval = null;
-        let typingTimeout = null;
-        // Initialize state
-        setDisplayedText(""); // Clear the displayed text
-        setShowDot(true); // Start with a blinking dot
-        setIsComplete(false); // Reset completion flag
-        // Start blinking dot effect
-        blinkingInterval = setInterval(() => {
+        const timers = timersRef.current;
+        const schedule = (fn, ms) => {
+            const id = setTimeout(() => {
+                timers.timeouts.delete(id);
+                fn();
+            }, ms);
+            timers.timeouts.add(id);
+        };
+        setDisplayedText("");
+        setShowDot(true);
+        setIsComplete(false);
+        timers.blinking = setInterval(() => {
             setShowDot((prev) => !prev);
         }, blinkingSpeed);
-        // Start typing after the initial delay
-        typingTimeout = setTimeout(() => {
-            if (blinkingInterval) {
-                clearInterval(blinkingInterval); // Stop blinking before typing
-                setShowDot(false); // Hide blinking dot
-            }
-            // Typing effect
-            let currentIndex = 0;
+        schedule(() => {
+            if (timers.blinking)
+                clearInterval(timers.blinking);
+            timers.blinking = null;
+            setShowDot(false);
+            let currentIndex = 1;
             const typeNextChar = () => {
                 if (currentIndex < text.length) {
-                    const charToAdd = text[currentIndex];
-                    setDisplayedText((prev) => prev + charToAdd); // Append character
                     currentIndex++;
-                    setTimeout(typeNextChar, typingSpeed); // Schedule next character
+                    setDisplayedText(text.slice(0, currentIndex));
+                    schedule(typeNextChar, typingSpeed);
                 }
                 else {
-                    setIsComplete(true); // Mark as complete
+                    setIsComplete(true);
                 }
             };
-            // Trigger the first character manually
             setDisplayedText(text.charAt(0));
-            currentIndex = 1;
-            // Schedule the rest of the characters
-            setTimeout(typeNextChar, typingSpeed);
+            schedule(typeNextChar, typingSpeed);
         }, initialDelay);
-        // Cleanup on unmount or dependencies change
-        return () => {
-            if (blinkingInterval)
-                clearInterval(blinkingInterval);
-            if (typingTimeout)
-                clearTimeout(typingTimeout);
-        };
-    }, [text, typingSpeed, initialDelay, blinkingSpeed]);
-    return { displayedText, showDot, isComplete };
+        return clearTimers;
+    }, [text, typingSpeed, initialDelay, blinkingSpeed, clearTimers]);
+    const revealAll = (0, react_1.useCallback)(() => {
+        clearTimers();
+        setDisplayedText(text ?? "");
+        setShowDot(false);
+        setIsComplete(true);
+    }, [text, clearTimers]);
+    return { displayedText, showDot, isComplete, revealAll };
 };
 exports.useTypewriter = useTypewriter;

package/dist/hooks/useTypewriter.test.js

@@ -68,4 +68,43 @@ describe("useTypewriter", () => {
         });
         expect(result.current.displayedText).toBe(sampleText.slice(0, 2));
     });
+    it("reveals the full text immediately when revealAll is called mid-typing", () => {
+        const { result } = (0, react_1.renderHook)(() => (0, useTypewriter_1.useTypewriter)(defaultOptions));
+        (0, react_1.act)(() => {
+            jest.advanceTimersByTime(defaultOptions.initialDelay + 100);
+        });
+        expect(result.current.isComplete).toBe(false);
+        (0, react_1.act)(() => {
+            result.current.revealAll();
+        });
+        expect(result.current.displayedText).toBe(sampleText);
+        expect(result.current.isComplete).toBe(true);
+        expect(result.current.showDot).toBe(false);
+        (0, react_1.act)(() => {
+            jest.advanceTimersByTime(sampleText.length * defaultOptions.typingSpeed);
+        });
+        expect(result.current.displayedText).toBe(sampleText);
+    });
+    it("reveals the full text when revealAll is called before typing starts", () => {
+        const { result } = (0, react_1.renderHook)(() => (0, useTypewriter_1.useTypewriter)(defaultOptions));
+        (0, react_1.act)(() => {
+            result.current.revealAll();
+        });
+        expect(result.current.displayedText).toBe(sampleText);
+        expect(result.current.isComplete).toBe(true);
+        expect(result.current.showDot).toBe(false);
+        (0, react_1.act)(() => {
+            jest.advanceTimersByTime(defaultOptions.initialDelay * 2);
+        });
+        expect(result.current.displayedText).toBe(sampleText);
+        expect(result.current.showDot).toBe(false);
+    });
+    it("stops all timers on unmount", () => {
+        const { unmount } = (0, react_1.renderHook)(() => (0, useTypewriter_1.useTypewriter)(defaultOptions));
+        (0, react_1.act)(() => {
+            jest.advanceTimersByTime(defaultOptions.initialDelay + 100);
+        });
+        unmount();
+        expect(jest.getTimerCount()).toBe(0);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heartraite",
-  "version": "1.0.213",
+  "version": "1.0.215",
   "description": "Heartraite npm package for common functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/enum/notification.enum.ts

@@ -2,4 +2,5 @@ export enum NotificationSetting {
   NEW_MATCH = "new-match",
   NEW_LIKE = "new-like",
   NEW_MESSAGE = "new-message",
+  MATCH_SUGGESTION = "match-suggestion",
 }

package/src/hooks/useTypewriter.test.ts

@@ -83,4 +83,51 @@ describe("useTypewriter", () => {
     });
     expect(result.current.displayedText).toBe(sampleText.slice(0, 2));
   });
+
+  it("reveals the full text immediately when revealAll is called mid-typing", () => {
+    const { result } = renderHook(() => useTypewriter(defaultOptions));
+
+    act(() => {
+      jest.advanceTimersByTime(defaultOptions.initialDelay + 100);
+    });
+    expect(result.current.isComplete).toBe(false);
+
+    act(() => {
+      result.current.revealAll();
+    });
+    expect(result.current.displayedText).toBe(sampleText);
+    expect(result.current.isComplete).toBe(true);
+    expect(result.current.showDot).toBe(false);
+
+    act(() => {
+      jest.advanceTimersByTime(sampleText.length * defaultOptions.typingSpeed);
+    });
+    expect(result.current.displayedText).toBe(sampleText);
+  });
+
+  it("reveals the full text when revealAll is called before typing starts", () => {
+    const { result } = renderHook(() => useTypewriter(defaultOptions));
+
+    act(() => {
+      result.current.revealAll();
+    });
+    expect(result.current.displayedText).toBe(sampleText);
+    expect(result.current.isComplete).toBe(true);
+    expect(result.current.showDot).toBe(false);
+
+    act(() => {
+      jest.advanceTimersByTime(defaultOptions.initialDelay * 2);
+    });
+    expect(result.current.displayedText).toBe(sampleText);
+    expect(result.current.showDot).toBe(false);
+  });
+
+  it("stops all timers on unmount", () => {
+    const { unmount } = renderHook(() => useTypewriter(defaultOptions));
+    act(() => {
+      jest.advanceTimersByTime(defaultOptions.initialDelay + 100);
+    });
+    unmount();
+    expect(jest.getTimerCount()).toBe(0);
+  });
 });

package/src/hooks/useTypewriter.ts

@@ -1,10 +1,10 @@
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 interface UseTypewriterOptions {
   text: string;
-  typingSpeed?: number; // Time in ms between each character
-  initialDelay?: number; // Time in ms before typing starts
-  blinkingSpeed?: number; // Time in ms for the blinking dot toggle
+  typingSpeed?: number;
+  initialDelay?: number;
+  blinkingSpeed?: number;
 }
 
 export const useTypewriter = ({
@@ -16,63 +16,73 @@ export const useTypewriter = ({
   const [isComplete, setIsComplete] = useState(false);
   const [displayedText, setDisplayedText] = useState("");
   const [showDot, setShowDot] = useState(false);
+  const timersRef = useRef<{
+    blinking: ReturnType<typeof setInterval> | null;
+    timeouts: Set<ReturnType<typeof setTimeout>>;
+  }>({ blinking: null, timeouts: new Set() });
+
+  const clearTimers = useCallback(() => {
+    const timers = timersRef.current;
+    if (timers.blinking) clearInterval(timers.blinking);
+    timers.blinking = null;
+    timers.timeouts.forEach(clearTimeout);
+    timers.timeouts.clear();
+  }, []);
 
   useEffect(() => {
     if (!text || text.length === 0) {
-      setDisplayedText(""); // No text to display
-      setIsComplete(true); // Mark typing as complete immediately
-      setShowDot(false); // No blinking dot for empty text
-      return; // Exit early if text is empty
+      setDisplayedText("");
+      setIsComplete(true);
+      setShowDot(false);
+      return;
     }
 
-    let blinkingInterval: NodeJS.Timeout | null = null;
-    let typingTimeout: NodeJS.Timeout | null = null;
+    const timers = timersRef.current;
+    const schedule = (fn: () => void, ms: number) => {
+      const id = setTimeout(() => {
+        timers.timeouts.delete(id);
+        fn();
+      }, ms);
+      timers.timeouts.add(id);
+    };
 
-    // Initialize state
-    setDisplayedText(""); // Clear the displayed text
-    setShowDot(true); // Start with a blinking dot
-    setIsComplete(false); // Reset completion flag
+    setDisplayedText("");
+    setShowDot(true);
+    setIsComplete(false);
 
-    // Start blinking dot effect
-    blinkingInterval = setInterval(() => {
+    timers.blinking = setInterval(() => {
       setShowDot((prev) => !prev);
     }, blinkingSpeed);
 
-    // Start typing after the initial delay
-    typingTimeout = setTimeout(() => {
-      if (blinkingInterval) {
-        clearInterval(blinkingInterval); // Stop blinking before typing
-        setShowDot(false); // Hide blinking dot
-      }
-
-      // Typing effect
-      let currentIndex = 0;
+    schedule(() => {
+      if (timers.blinking) clearInterval(timers.blinking);
+      timers.blinking = null;
+      setShowDot(false);
 
+      let currentIndex = 1;
       const typeNextChar = () => {
         if (currentIndex < text.length) {
-          const charToAdd = text[currentIndex];
-          setDisplayedText((prev) => prev + charToAdd); // Append character
           currentIndex++;
-          setTimeout(typeNextChar, typingSpeed); // Schedule next character
+          setDisplayedText(text.slice(0, currentIndex));
+          schedule(typeNextChar, typingSpeed);
         } else {
-          setIsComplete(true); // Mark as complete
+          setIsComplete(true);
         }
       };
 
-      // Trigger the first character manually
       setDisplayedText(text.charAt(0));
-      currentIndex = 1;
-
-      // Schedule the rest of the characters
-      setTimeout(typeNextChar, typingSpeed);
+      schedule(typeNextChar, typingSpeed);
     }, initialDelay);
 
-    // Cleanup on unmount or dependencies change
-    return () => {
-      if (blinkingInterval) clearInterval(blinkingInterval);
-      if (typingTimeout) clearTimeout(typingTimeout);
-    };
-  }, [text, typingSpeed, initialDelay, blinkingSpeed]);
+    return clearTimers;
+  }, [text, typingSpeed, initialDelay, blinkingSpeed, clearTimers]);
+
+  const revealAll = useCallback(() => {
+    clearTimers();
+    setDisplayedText(text ?? "");
+    setShowDot(false);
+    setIsComplete(true);
+  }, [text, clearTimers]);
 
-  return { displayedText, showDot, isComplete };
+  return { displayedText, showDot, isComplete, revealAll };
 };