Skip to content

An open source, self-hosted, real-time port monitoring and discovery tool.

8.4 KB
Raw Blame
import { useState, useCallback, useEffect } from 'react';
import {
  parseChangelog,
  getNewVersions,
  setLastSeenVersion,
  combineVersionChanges,
  groupVersionChanges,
  compareVersions
} from '../whats-new';
import whatsNewConfig from '../whats-new-config';
import Logger from '../logger';

const logger = new Logger('useWhatsNew');

export function useWhatsNew() {
  const [isModalOpen, setIsModalOpen] = useState(false);
  const [whatsNewData, setWhatsNewData] = useState({});
  const [newVersions, setNewVersions] = useState([]);
  const [currentVersion, setCurrentVersion] = useState(null);
  const [isDismissed, setIsDismissed] = useState(() => {
    try {
      return localStorage.getItem('portracker_whats_new_dismissed') === 'true';
    } catch {
      return false;
    }
  });
  const [hasNewFeaturesToShow, setHasNewFeaturesToShow] = useState(false);

  const shouldShowButton = hasNewFeaturesToShow && !isDismissed;

  const handleClose = useCallback(() => {
    setIsModalOpen(false);
  }, []);

  const handleShow = useCallback(() => {
    setIsModalOpen(true);
  }, []);

  const handleDismiss = useCallback(() => {
    try {
      setIsDismissed(true);
      setHasNewFeaturesToShow(false);
      localStorage.setItem('portracker_whats_new_dismissed', 'true');
      if (newVersions.length > 0) {
        setLastSeenVersion(newVersions[0]);
      }
    } catch (error) {
      logger.warn('Failed to dismiss What\'s New:', error);
    }
  }, [newVersions]);

  useEffect(() => {
    const initializeWhatsNew = async () => {
      try {
        const versionResponse = await fetch('/api/version');
        if (!versionResponse.ok) return;
        
        const versionData = await versionResponse.json();
        if (!versionData?.version) return;
        
        setCurrentVersion(versionData.version);
        
        const changelogResponse = await fetch('/api/changelog');
        if (!changelogResponse.ok) return;
        
        const changelogData = await changelogResponse.json();
        const changelogText = changelogData.content;
        const parsedVersions = parseChangelog(changelogText);
        
        if (Object.keys(parsedVersions).length === 0) return;
        
        const urlParams = new URLSearchParams(window.location.search);
        const debugMode = urlParams.get('whatsnew') === '1';
        
        if (debugMode) {
          logger.debug('Debug mode: forcing What\'s New display');
          setWhatsNewData(parsedVersions);
          setNewVersions(Object.keys(parsedVersions).sort((a, b) => compareVersions(b, a)));
          setHasNewFeaturesToShow(true);
          setIsDismissed(false);
          setIsModalOpen(true);
          return;
        }
        
        const lastSeenVersion = localStorage.getItem('portracker_last_seen_version');
        let newVersionsList;
        
        logger.debug('What\'s New initialization:', {
          currentVersion: versionData.version,
          lastSeenVersion,
          isDismissed,
          parsedVersionsCount: Object.keys(parsedVersions).length
        });
        
        if (parsedVersions) {
          newVersionsList = getNewVersions(parsedVersions, lastSeenVersion);
          
          logger.debug('New versions found:', newVersionsList);
          
          if (newVersionsList.length > 0 && lastSeenVersion) {
            const hasNewerVersion = compareVersions(newVersionsList[0], lastSeenVersion) > 0;
            if (hasNewerVersion) {
              setIsDismissed(false);
              try {
                localStorage.removeItem('portracker_whats_new_dismissed');
              } catch (error) {
                void error;
              }
            }
          }
          
          if (newVersionsList.length > 0) {
            setWhatsNewData(parsedVersions);
            setNewVersions(newVersionsList);
            setHasNewFeaturesToShow(true);
            
            logger.debug('Should show modal:', {
              newVersionsCount: newVersionsList.length,
              isDismissed
            });
            
            const shouldAutoOpen = !isDismissed && !!lastSeenVersion;

            if (shouldAutoOpen) {
              logger.debug('Opening What\'s New modal');
              setTimeout(() => {
                setIsModalOpen(true);
              }, 1000);
            }
          }
        }
      } catch (error) {
        logger.error('Failed to initialize What\'s New:', error);
      }
    };

    initializeWhatsNew();
  }, [isDismissed]);

  const buildCombinedChanges = (versions, versionKeys, mergeTitles) => {
    const combined = combineVersionChanges(versions, []);
    const perVersion = groupVersionChanges(versions, versionKeys);
    const mergeSet = new Set(
      Array.isArray(mergeTitles) ? mergeTitles.map((title) => title.toLowerCase()) : []
    );
    const mergedByCategory = new Map();

    for (const versionData of perVersion) {
      const changes = versionData.changes || {};
      for (const [category, features] of Object.entries(changes)) {
        if (!Array.isArray(features) || features.length === 0) continue;
        if (!combined[category]) combined[category] = [];

        for (const feature of features) {
          const title = feature?.title || '';
          const titleKey = title.toLowerCase();

          if (mergeSet.has(titleKey)) {
            let categoryMap = mergedByCategory.get(category);
            if (!categoryMap) {
              categoryMap = new Map();
              mergedByCategory.set(category, categoryMap);
            }

            let mergedFeature = categoryMap.get(titleKey);
            if (!mergedFeature) {
              mergedFeature = {
                title,
                description: '',
                details: []
              };
              categoryMap.set(titleKey, mergedFeature);
              combined[category].push(mergedFeature);
            }

            mergedFeature.details.push({
              title: versionData.version,
              description: feature.description || ''
            });
          } else {
            combined[category].push(feature);
          }
        }
      }
    }

    return combined;
  };

  const getModalProps = () => {
    const version = newVersions.length > 1
      ? `${newVersions[newVersions.length - 1]} - ${newVersions[0]}`
      : (newVersions.length > 0 ? newVersions[0] : currentVersion);

    const changes = newVersions.length > 0
      ? combineVersionChanges(whatsNewData, newVersions)
      : whatsNewData[currentVersion] || {};
    
    let groupedChanges = newVersions.length > 0
      ? groupVersionChanges(whatsNewData, newVersions)
      : null;

    const combineGroups = Array.isArray(whatsNewConfig?.combineWhatsNewGroups)
      ? whatsNewConfig.combineWhatsNewGroups
      : [];

    if (groupedChanges && combineGroups.length > 0) {
      const combinedGroups = [];
      const consumedVersions = new Set();
      const versionSet = new Set(newVersions);

      for (const versionData of groupedChanges) {
        if (consumedVersions.has(versionData.version)) {
          continue;
        }

        const group = combineGroups.find((entry) =>
          Array.isArray(entry?.versions) && entry.versions.includes(versionData.version)
        );

        if (!group) {
          combinedGroups.push(versionData);
          consumedVersions.add(versionData.version);
          continue;
        }

        const presentVersions = group.versions.filter((v) => versionSet.has(v));
        if (presentVersions.length <= 1) {
          combinedGroups.push(versionData);
          consumedVersions.add(versionData.version);
          continue;
        }

        presentVersions.forEach((v) => consumedVersions.add(v));

        const sortedVersions = presentVersions.sort((a, b) => compareVersions(b, a));
        const combinedVersionLabel = sortedVersions.length > 1
          ? `${sortedVersions[sortedVersions.length - 1]} - ${sortedVersions[0]}`
          : sortedVersions[0];

        const mergedChanges = group.mergeTitles?.length
          ? buildCombinedChanges(whatsNewData, sortedVersions, group.mergeTitles)
          : combineVersionChanges(whatsNewData, sortedVersions);

        combinedGroups.push({
          version: combinedVersionLabel,
          changes: mergedChanges
        });
      }

      groupedChanges = combinedGroups;
    }

    const props = {
      isOpen: isModalOpen,
      onClose: handleClose,
      onDismiss: handleDismiss,
      version,
      changes,
      groupedChanges
    };

    return props;
  };

  return {
    shouldShowButton,
    handleShow,
    getModalProps
  };
}