feat: add change log (#1734)

Co-authored-by: Himself65 <himself65@outlook.com>

apps/web/src/hooks/__tests__/index.spec.tsx

@@ -25,7 +25,12 @@ import {
 import { LocalPlugin } from '../../plugins/local';
 import type { LocalWorkspace } from '../../shared';
 import { BlockSuiteWorkspace, WorkspaceSubPath } from '../../shared';
-import { useIsFirstLoad, useOpenTips } from '../affine/use-is-first-load';
+import {
+  useGuideHidden,
+  useGuideHiddenUntilNextUpdate,
+  useLastVersion,
+  useTipsDisplayStatus,
+} from '../affine/use-is-first-load';
 import {
   useRecentlyViewed,
   useSyncRecentViewsWithRouter,
@@ -348,20 +353,47 @@ describe('useRecentlyViewed', () => {
   });
 });
 describe('useIsFirstLoad', () => {
-  test('basic', async () => {
-    const firstLoad = renderHook(() => useIsFirstLoad());
-    const setFirstLoad = firstLoad.result.current[1];
-    expect(firstLoad.result.current[0]).toEqual(true);
-    setFirstLoad(false);
-    firstLoad.rerender();
-    expect(firstLoad.result.current[0]).toEqual(false);
+  test('useLastVersion', async () => {
+    const lastVersion = renderHook(() => useLastVersion());
+    const setLastVersion = lastVersion.result.current[1];
+    expect(lastVersion.result.current[0]).toEqual('0.0.0');
+    setLastVersion('testVersion');
+    lastVersion.rerender();
+    expect(lastVersion.result.current[0]).toEqual('testVersion');
   });
-  test('useOpenTips', async () => {
-    const openTips = renderHook(() => useOpenTips());
-    const setOpenTips = openTips.result.current[1];
-    expect(openTips.result.current[0]).toEqual(false);
-    setOpenTips(true);
-    openTips.rerender();
-    expect(openTips.result.current[0]).toEqual(true);
+  test('useGuideHidden', async () => {
+    const guideHidden = renderHook(() => useGuideHidden());
+    const setGuideHidden = guideHidden.result.current[1];
+    expect(guideHidden.result.current[0]).toEqual({});
+    setGuideHidden({ test: true });
+    guideHidden.rerender();
+    expect(guideHidden.result.current[0]).toEqual({ test: true });
+  });
+  test('useGuideHiddenUntilNextUpdate', async () => {
+    const guideHiddenUntilNextUpdate = renderHook(() =>
+      useGuideHiddenUntilNextUpdate()
+    );
+    const setGuideHiddenUntilNextUpdate =
+      guideHiddenUntilNextUpdate.result.current[1];
+    expect(guideHiddenUntilNextUpdate.result.current[0]).toEqual({});
+    setGuideHiddenUntilNextUpdate({ test: true });
+    guideHiddenUntilNextUpdate.rerender();
+    expect(guideHiddenUntilNextUpdate.result.current[0]).toEqual({
+      test: true,
+    });
+  });
+  test('useTipsDisplayStatus', async () => {
+    const tipsDisplayStatus = renderHook(() => useTipsDisplayStatus());
+    const setTipsDisplayStatus = tipsDisplayStatus.result.current;
+    expect(tipsDisplayStatus.result.current).toEqual({
+      quickSearchTips: {
+        permanentlyHidden: true,
+        hiddenUntilNextUpdate: true,
+      },
+      changeLog: {
+        permanentlyHidden: true,
+        hiddenUntilNextUpdate: true,
+      },
+    });
   });
 });

apps/web/src/hooks/affine/use-is-first-load.ts

@@ -1,12 +1,74 @@
-import { useAtom } from 'jotai';
+import { config } from '@affine/env';
+import { useAtom, useAtomValue, useSetAtom } from 'jotai';
+import { useEffect } from 'react';
 
-import { isFirstLoadAtom, openTipsAtom } from '../../atoms/first-load';
+import {
+  guideHiddenAtom,
+  guideHiddenUntilNextUpdateAtom,
+  lastVersionAtom,
+} from '../../atoms/first-load';
 
-export function useIsFirstLoad() {
-  const [isFirstLoad, setIsFirstLoad] = useAtom(isFirstLoadAtom);
-  return [isFirstLoad, setIsFirstLoad] as const;
+export function useLastVersion() {
+  return useAtom(lastVersionAtom);
 }
-export function useOpenTips() {
-  const [openTips, setOpenTips] = useAtom(openTipsAtom);
-  return [openTips, setOpenTips] as const;
+
+export function useGuideHidden() {
+  return useAtom(guideHiddenAtom);
+}
+
+export function useGuideHiddenUntilNextUpdate() {
+  return useAtom(guideHiddenUntilNextUpdateAtom);
+}
+
+const TIPS = {
+  quickSearchTips: true,
+  changeLog: true,
+};
+
+export function useTipsDisplayStatus() {
+  const permanentlyHiddenTips = useAtomValue(guideHiddenAtom);
+  const hiddenUntilNextUpdateTips = useAtomValue(
+    guideHiddenUntilNextUpdateAtom
+  );
+
+  return {
+    quickSearchTips: {
+      permanentlyHidden: permanentlyHiddenTips.quickSearchTips || true,
+      hiddenUntilNextUpdate: hiddenUntilNextUpdateTips.quickSearchTips || true,
+    },
+    changeLog: {
+      permanentlyHidden: permanentlyHiddenTips.changeLog || true,
+      hiddenUntilNextUpdate: hiddenUntilNextUpdateTips.changeLog || true,
+    },
+  };
+}
+
+export function useUpdateTipsOnVersionChange() {
+  const [lastVersion, setLastVersion] = useLastVersion();
+  const currentVersion = config.gitVersion;
+  const tipsDisplayStatus = useTipsDisplayStatus();
+  const setPermanentlyHiddenTips = useSetAtom(guideHiddenAtom);
+  const setHiddenUntilNextUpdateTips = useSetAtom(
+    guideHiddenUntilNextUpdateAtom
+  );
+
+  useEffect(() => {
+    if (lastVersion !== currentVersion) {
+      setLastVersion(currentVersion);
+      const newHiddenUntilNextUpdateTips = { ...TIPS };
+      const newPermanentlyHiddenTips = { ...TIPS, changeLog: false };
+      Object.keys(tipsDisplayStatus).forEach(tipKey => {
+        newHiddenUntilNextUpdateTips[tipKey as keyof typeof TIPS] = false;
+      });
+      setHiddenUntilNextUpdateTips(newHiddenUntilNextUpdateTips);
+      setPermanentlyHiddenTips(newPermanentlyHiddenTips);
+    }
+  }, [
+    currentVersion,
+    lastVersion,
+    setLastVersion,
+    setPermanentlyHiddenTips,
+    setHiddenUntilNextUpdateTips,
+    tipsDisplayStatus,
+  ]);
 }