Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

4.3 KB
Raw Blame
import { createContext, type ReactNode, useContext, useState } from "react";
import { useLocation } from "react-router-dom";
import { ROUTES, resolveCollectionRoute } from "@/router/routes";

export type MemoTimeBasis = "create_time" | "update_time";

/** Upper bound on feed columns, in display order. 1 = single reading column; 0 = as many as fit. */
export const MAX_COLUMNS_VALUES = [1, 2, 3, 0] as const;
export type MemoMaxColumns = (typeof MAX_COLUMNS_VALUES)[number];

interface ViewState {
  orderByTimeAsc: boolean;
  timeBasis?: MemoTimeBasis;
  sortTimeField?: MemoTimeBasis;
  compactMode: boolean;
  maxColumns: MemoMaxColumns;
}

interface ViewContextValue {
  orderByTimeAsc: boolean;
  timeBasis: MemoTimeBasis;
  compactMode: boolean;
  maxColumns: MemoMaxColumns;
  setOrderByTimeAsc: (value: boolean) => void;
  setTimeBasis: (field: MemoTimeBasis) => void;
  setCompactMode: (value: boolean) => void;
  setMaxColumns: (value: MemoMaxColumns) => void;
}

const ViewContext = createContext<ViewContextValue | null>(null);

const LOCAL_STORAGE_KEY = "memos-view-setting";

const DEFAULT_VIEW_STATE: ViewState = { orderByTimeAsc: false, compactMode: false, maxColumns: 1 };

export function ViewProvider({ children, enabled = true }: { children: ReactNode; enabled?: boolean }) {
  const getInitialState = (): ViewState => {
    try {
      const cached = localStorage.getItem(LOCAL_STORAGE_KEY);
      if (cached) {
        const data = JSON.parse(cached) as Partial<ViewState>;
        const cachedTimeBasis = data.timeBasis ?? data.sortTimeField;
        const timeBasis = cachedTimeBasis === "create_time" || cachedTimeBasis === "update_time" ? cachedTimeBasis : undefined;
        const maxColumns = MAX_COLUMNS_VALUES.includes(data.maxColumns as MemoMaxColumns)
          ? (data.maxColumns as MemoMaxColumns)
          : DEFAULT_VIEW_STATE.maxColumns;
        return {
          orderByTimeAsc: Boolean(data.orderByTimeAsc ?? DEFAULT_VIEW_STATE.orderByTimeAsc),
          timeBasis,
          compactMode: Boolean(data.compactMode ?? DEFAULT_VIEW_STATE.compactMode),
          maxColumns,
        };
      }
    } catch (error) {
      console.warn("Failed to load view settings from localStorage:", error);
    }
    return { ...DEFAULT_VIEW_STATE };
  };

  const [viewState, setViewState] = useState(getInitialState);
  // Keep the saved Timeline preferences while other views use their default presentation.
  const activeState = enabled ? viewState : DEFAULT_VIEW_STATE;
  const timeBasis = activeState.timeBasis ?? "create_time";

  const persistToStorage = (newState: ViewState) => {
    try {
      localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(newState));
    } catch (error) {
      console.warn("Failed to persist view settings:", error);
    }
  };

  const updateState = (patch: Partial<ViewState>) => {
    setViewState((prev) => {
      const newState = { ...prev, ...patch };
      persistToStorage(newState);
      return newState;
    });
  };

  const setOrderByTimeAsc = (value: boolean) => updateState({ orderByTimeAsc: value });
  const setTimeBasis = (field: MemoTimeBasis) => updateState({ timeBasis: field });
  const setCompactMode = (value: boolean) => updateState({ compactMode: value });
  const setMaxColumns = (value: MemoMaxColumns) => updateState({ maxColumns: value });

  return (
    <ViewContext.Provider
      value={{
        orderByTimeAsc: activeState.orderByTimeAsc,
        timeBasis,
        compactMode: activeState.compactMode,
        maxColumns: activeState.maxColumns,
        setOrderByTimeAsc,
        setTimeBasis,
        setCompactMode,
        setMaxColumns,
      }}
    >
      {children}
    </ViewContext.Provider>
  );
}

/** Timeline preferences also apply to its sidebar statistics and date filters. */
export function TimelineViewProvider({ children }: { children: ReactNode }) {
  const { pathname } = useLocation();
  const route = resolveCollectionRoute(pathname);
  const collectionPath = route.pathname.toLowerCase();
  const enabled = route.isCollection && (collectionPath === ROUTES.HOME || collectionPath === ROUTES.EXPLORE);
  return <ViewProvider enabled={enabled}>{children}</ViewProvider>;
}

export function useView() {
  const context = useContext(ViewContext);
  if (!context) {
    throw new Error("useView must be used within ViewProvider");
  }
  return context;
}