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.

7.1 KB
Raw Blame
import { uniqBy } from "lodash-es";
import { createContext, type ReactNode, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
import { useLocation, useSearchParams } from "react-router-dom";

export type FilterFactor =
  | "tagSearch"
  | "visibility"
  | "contentSearch"
  | "celSearch"
  | "displayTime"
  | "pinned"
  | "property.hasLink"
  | "property.hasTaskList"
  | "property.hasCode"
  | "property.hasLocation"
  | "property.hasAttachments"
  | "property.hasImage";

export interface MemoFilter {
  factor: FilterFactor;
  value: string;
}

export const getMemoFilterKey = (filter: MemoFilter): string => `${filter.factor}:${filter.value}`;

export const parseFilterQuery = (query: string | null): MemoFilter[] => {
  if (!query) return [];
  try {
    return query.split(",").map((filterStr) => {
      const separatorIndex = filterStr.indexOf(":");
      const factor = separatorIndex === -1 ? filterStr : filterStr.slice(0, separatorIndex);
      const value = separatorIndex === -1 ? "" : filterStr.slice(separatorIndex + 1);
      return {
        factor: factor as FilterFactor,
        value: decodeURIComponent(value || ""),
      };
    });
  } catch {
    return [];
  }
};

export const stringifyFilters = (filters: MemoFilter[]): string => {
  return filters.map((filter) => `${filter.factor}:${encodeURIComponent(filter.value)}`).join(",");
};

/** The `?filter=` search string that carries these filters in a URL, or "" when there are none. */
export const getFilterSearch = (filters: MemoFilter[]): string => {
  const filterQuery = stringifyFilters(filters);
  return filterQuery ? `?${new URLSearchParams({ filter: filterQuery })}` : "";
};

/** Search filters carry the user's query itself (plain words or a CEL expression), as opposed to facets. */
export const isSearchFilter = (filter: MemoFilter): boolean => filter.factor === "contentSearch" || filter.factor === "celSearch";

export const replaceFiltersByFactor = (filters: MemoFilter[], factor: FilterFactor, replacements: MemoFilter[]): MemoFilter[] => [
  ...filters.filter((filter) => filter.factor !== factor),
  ...replacements,
];

interface MemoFilterContextValue {
  filters: MemoFilter[];
  memoView: string | undefined;
  hasActiveFilters: boolean;
  getFiltersByFactor: (factor: FilterFactor) => MemoFilter[];
  setFilters: (filters: MemoFilter[]) => void;
  addFilter: (filter: MemoFilter) => void;
  removeFilter: (predicate: (f: MemoFilter) => boolean) => void;
  removeFiltersByFactor: (factor: FilterFactor) => void;
  clearAllFilters: () => void;
  setMemoView: (memoView?: string) => void;
  hasFilter: (filter: MemoFilter) => boolean;
}

const MemoFilterContext = createContext<MemoFilterContextValue | null>(null);

export function MemoFilterProvider({ children }: { children: ReactNode }) {
  const [searchParams, setSearchParams] = useSearchParams();
  const locationStateRef = useRef(useLocation().state);
  const skipStoreSyncRef = useRef(false);
  const lastSyncedUrlRef = useRef("");
  const lastSyncedStoreRef = useRef("");

  // Initialize from URL
  const [filters, setFiltersState] = useState<MemoFilter[]>(() => {
    return parseFilterQuery(searchParams.get("filter"));
  });
  const [memoView, setMemoViewState] = useState<string | undefined>(undefined);

  // Sync URL to state when URL changes externally
  useEffect(() => {
    const filterParam = searchParams.get("filter") || "";
    if (filterParam !== lastSyncedUrlRef.current) {
      // The store still contains the previous page’s filters in this commit.
      // Do not write them back over the destination URL before state catches up.
      skipStoreSyncRef.current = true;
      lastSyncedUrlRef.current = filterParam;
      const newFilters = parseFilterQuery(filterParam);
      setFiltersState(newFilters);
      lastSyncedStoreRef.current = stringifyFilters(newFilters);
    }
  }, [searchParams]);

  // Sync state to URL when state changes
  useEffect(() => {
    if (skipStoreSyncRef.current) {
      skipStoreSyncRef.current = false;
      return;
    }
    const storeString = stringifyFilters(filters);
    if (storeString !== lastSyncedStoreRef.current && storeString !== lastSyncedUrlRef.current) {
      lastSyncedStoreRef.current = storeString;
      const newParams = new URLSearchParams(searchParams);
      if (filters.length > 0) {
        newParams.set("filter", storeString);
      } else {
        newParams.delete("filter");
      }
      setSearchParams(newParams, { replace: true, state: locationStateRef.current });
      lastSyncedUrlRef.current = filters.length > 0 ? storeString : "";
    }
  }, [filters, searchParams, setSearchParams]);

  const getFiltersByFactor = useCallback((factor: FilterFactor) => filters.filter((f) => f.factor === factor), [filters]);

  const setFilters = useCallback((newFilters: MemoFilter[]) => {
    setFiltersState(newFilters);
  }, []);

  const addFilter = useCallback((filter: MemoFilter) => {
    setFiltersState((prev) => uniqBy([...prev, filter], getMemoFilterKey));
  }, []);

  const removeFilter = useCallback((predicate: (f: MemoFilter) => boolean) => {
    setFiltersState((prev) => prev.filter((f) => !predicate(f)));
  }, []);

  const removeFiltersByFactor = useCallback((factor: FilterFactor) => {
    setFiltersState((prev) => prev.filter((f) => f.factor !== factor));
  }, []);

  const clearAllFilters = useCallback(() => {
    setFiltersState([]);
    setMemoViewState(undefined);
  }, []);

  const setMemoView = useCallback((newMemoView?: string) => {
    setMemoViewState(newMemoView);
  }, []);

  const hasFilter = useCallback((filter: MemoFilter) => filters.some((f) => getMemoFilterKey(f) === getMemoFilterKey(filter)), [filters]);

  const hasActiveFilters = filters.length > 0 || memoView !== undefined;
  const value = useMemo(
    () => ({
      filters,
      memoView,
      hasActiveFilters,
      getFiltersByFactor,
      setFilters,
      addFilter,
      removeFilter,
      removeFiltersByFactor,
      clearAllFilters,
      setMemoView,
      hasFilter,
    }),
    [
      filters,
      memoView,
      hasActiveFilters,
      getFiltersByFactor,
      setFilters,
      addFilter,
      removeFilter,
      removeFiltersByFactor,
      clearAllFilters,
      setMemoView,
      hasFilter,
    ],
  );

  return <MemoFilterContext.Provider value={value}>{children}</MemoFilterContext.Provider>;
}

export function useMemoFilterContext() {
  const context = useContext(MemoFilterContext);
  if (!context) {
    throw new Error("useMemoFilterContext must be used within MemoFilterProvider");
  }
  return context;
}

// Alias for backwards compatibility during migration
export const useMemoFilter = useMemoFilterContext;

const NO_TERMS: string[] = [];

/**
 * The words of the active plain-text search, in the order the user typed them. Safe outside a
 * provider (share previews, tests), where there is no search and therefore nothing to match.
 */
export function useContentSearchTerms(): string[] {
  const filters = useContext(MemoFilterContext)?.filters;
  return useMemo(() => {
    const terms = (filters ?? []).filter((filter) => filter.factor === "contentSearch").map((filter) => filter.value);
    return terms.length > 0 ? terms : NO_TERMS;
  }, [filters]);
}