commit d28f78d61f56728a9d088044e87523aa09452d75 · indexx.dev/static

+9 -15
src/components/jsx/Tealfm.jsx
···

       4
       4
        
       export default function Tealfm() {

     

       5
       5
        
           const [data, setData] = useState(null);

     

       6
       6
        
           const [error, setError] = useState(null);

     

       7
       7
       +
           const [isCurrentlyPlaying, setIsCurrentlyPlaying] = useState(false);

     

       7
       8
        
       

     

       8
       9
        
           useEffect(() => {

     

       9
       10
        
               const fetchStatus = async () => {

     
···

       12
       13
        
                   const lastPlayedCollection = "fm.teal.alpha.feed.play";

     

       13
       14
        
       

     

       14
       15
        
                   try {

     

       15
       15
       -
                       // --- 1. Attempt to fetch the actor status record ---

     

       16
       16
        
                       const statusUrl =

     

       17
       17
        
                           `https://pds.indexx.dev/xrpc/com.atproto.repo.getRecord?repo=${repo}&collection=${statusCollection}&rkey=self`;

     

       18
       18
        
                       const statusRes = await fetch(statusUrl);

     
···

       23
       23
        
       

     

       24
       24
        
                       const statusData = await statusRes.json();

     

       25
       25
        
                       const statusValue = statusData?.value;

     

       26
       26
       -
                       const nowTimestamp = Math.floor(Date.now() / 1000); // Current time in seconds

     

       26
       26
       +
                       const nowTimestamp = Math.floor(Date.now() / 1000);

     

       27
       27
        
       

     

       28
       28
        
                       const isExpired = statusValue?.expiry &&

     

       29
       29
        
                           nowTimestamp > parseInt(statusValue.expiry, 10);

     
···

       31
       31
        
       

     

       32
       32
        
                       let status;

     

       33
       33
        
       

     

       34
       34
       -
                       // Check if the status is valid (not expired and not empty)

     

       35
       34
        
                       if (statusValue && !isExpired && !isItemEmpty) {

     

       36
       36
       -
                           // Status is valid, use it

     

       37
       35
        
                           const latest = statusValue.item;

     

       38
       36
        
       

     

       39
       37
        
                           status = {

     
···

       41
       39
        
                               artist: latest.artists.map((artist) =>

     

       42
       40
        
                                   artist.artistName

     

       43
       41
        
                               ).join(", "),

     

       44
       44
       -
                               albumArt: latest.releaseMbId

     

       45
       45
       -
                                   ? `https://coverartarchive.org/release/${latest.releaseMbId}/front-500`

     

       46
       46
       -
                                   : "/default-album-art.png", // Fallback image needed if not present

     

       47
       47
       -
                               createdAt: parseInt(statusValue.time, 10) * 1000, // Convert seconds to milliseconds

     

       42
       42
       +
                               createdAt: parseInt(statusValue.time, 10) * 1000,

     

       48
       43
        
                               link: latest.originUrl ?? "",

     

       49
       44
        
                           };

     

       50
       45
        
                           setData(status);

     

       51
       51
       -
                           return; // Exit if a valid status is found

     

       46
       46
       +
                           setIsCurrentlyPlaying(true);

     

       47
       47
       +
                           return;

     

       52
       48
        
                       }

     

       53
       49
        
       

     

       54
       54
       -
                       // --- 2. If status is expired or empty, fetch the last played record (Original Logic) ---

     

       55
       50
        
                       console.log(

     

       56
       51
        
                           "Status expired or empty. Falling back to last played record.",

     

       57
       52
        
                       );

     
···

       84
       79
        
                               link: latest.originUrl ?? "",

     

       85
       80
        
                           };

     

       86
       81
        
                           setData(status);

     

       82
       82
       +
                           setIsCurrentlyPlaying(false);

     

       87
       83
        
                       } else {

     

       88
       84
        
                           console.log("No records found in last played collection.");

     

       89
       89
       -
                           // Optionally set a specific state for 'no data found'

     

       85
       85
       +
                           setIsCurrentlyPlaying(false);

     

       90
       86
        
                       }

     

       91
       87
        
                   } catch (err) {

     

       92
       88
        
                       console.error("Fetch failed:", err);

     

       93
       89
        
                       setError(err.message);

     

       90
       90
       +
                       setIsCurrentlyPlaying(false);

     

       94
       91
        
                   }

     

       95
       92
        
               };

     

       96
       93
        
       

     
···

       100
       97
        
           if (error) return <span>Error: {error}</span>;

     

       101
       98
        
           if (!data) return null;

     

       102
       99
        
       

     

       103
       103
       -
           // --- Time Ago and Styling Logic (Unchanged) ---

     

       104
       100
        
           let timeAgo = "";

     

       105
       101
        
           let oldStatusClasses = "";

     

       106
       102
        
       

     

       107
       107
       -
           // data.createdAt is either a string (from listRecords) or a number (from getRecord)

     

       108
       103
        
           const date = new Date(data.createdAt);

     

       109
       104
        
           const now = new Date();

     

       110
       105
        
           const diff = now.getTime() - date.getTime();

     
···

       121
       116
        
           oldStatusClasses = days > 3

     

       122
       117
        
               ? "opacity-75 text-decoration-line-through"

     

       123
       118
        
               : "";

     

       124
       124
       -
           // --- End Time Ago and Styling Logic ---

     

       125
       119
        
       

     

       126
       120
        
           return (

     

       127
       121
        
               <a

     
···

       130
       124
        
                   target="_blank"

     

       131
       125
        
                   className={oldStatusClasses}

     

       132
       126
        
               >

     

       133
       133
       -
                   <AudioVisualizer isSilent={!data.nowPlaying} />

     

       127
       127
       +
                   <AudioVisualizer isSilent={!isCurrentlyPlaying} />

     

       134
       128
        
                   <div

     

       135
       129
        
                       style={{

     

       136
       130
        
                           display: "flex",