Skip to content

A local-first personal finance app

13.9 KB
Raw Blame
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import type { ReactNode, RefObject } from 'react';
import { Trans } from 'react-i18next';

import { styles } from '@actual-app/components/styles';
import { theme } from '@actual-app/components/theme';
import { EditorView } from '@codemirror/view';
import CodeMirror, { EditorState } from '@uiw/react-codemirror';
import type { ReactCodeMirrorProps } from '@uiw/react-codemirror';

import { autocompleteTabAcceptHighest } from '#components/codemirror/autocompleteTabAccept';
import { DateSelect } from '#components/select/DateSelect';
import { useDateFormat } from '#hooks/useDateFormat';
import { useTheme } from '#style/theme';

import {
  excelFormulaExtension,
  formatMonthYear,
  parseMonthYear,
} from './codeMirror-excelLanguage';
import type {
  FormulaBadgeClick,
  MonthYearFormat,
} from './codeMirror-excelLanguage';
import { budgetQueryDimensions } from './formulaCatalog';

type FormulaMode = 'transaction' | 'query';

type FormulaEditorProps = {
  value: string;
  onChange: (value: string) => void;
  mode: FormulaMode;
  height?: string;
  disabled?: boolean;
  queries?: Record<string, unknown>;
  variables?: Record<string, number | string>;
  categoryBadges?: Record<string, string>;
  singleLine?: boolean;
  showLineNumbers?: boolean;
};

type BadgePickerState = {
  view: FormulaBadgeClick['view'];
  anchorRect: DOMRect;
  from: number;
  to: number;
  label: string;
};

type TimeframePickerState = BadgePickerState & {
  month: string;
  format: MonthYearFormat;
};

type CategoryPickerState = BadgePickerState & {
  selectedCategoryIds: string[];
};

function getCurrentMonth() {
  return new Date().toISOString().slice(0, 7);
}

export function FormulaEditor({
  value,
  onChange,
  mode,
  height = '100%',
  disabled = false,
  queries,
  variables,
  categoryBadges,
  singleLine = false,
  showLineNumbers = true,
}: FormulaEditorProps) {
  const [activeTheme] = useTheme();
  const dateFormat = useDateFormat() || 'MM/dd/yyyy';
  const [queryPicker, setQueryPicker] = useState<BadgePickerState | null>(null);
  const [dimensionPicker, setDimensionPicker] =
    useState<BadgePickerState | null>(null);
  const [timeframePicker, setTimeframePicker] =
    useState<TimeframePickerState | null>(null);
  const [categoryPicker, setCategoryPicker] =
    useState<CategoryPickerState | null>(null);
  const suppressBadgePickerUntilRef = useRef(0);
  const badgePickerPopoverRef = useRef<HTMLDivElement | null>(null);

  const isDarkTheme = useMemo(() => {
    if (activeTheme === 'dark' || activeTheme === 'midnight') {
      return true;
    }
    if (activeTheme === 'auto') {
      return window.matchMedia('(prefers-color-scheme: dark)').matches;
    }
    return false;
  }, [activeTheme]);

  const closeBadgePickers = useCallback(() => {
    setQueryPicker(null);
    setDimensionPicker(null);
    setTimeframePicker(null);
    setCategoryPicker(null);
  }, []);

  const openBadgePicker = useCallback(
    (details: FormulaBadgeClick) => {
      if (Date.now() < suppressBadgePickerUntilRef.current) {
        return;
      }

      closeBadgePickers();

      const picker = {
        view: details.view,
        anchorRect: details.anchorRect,
        from: details.from,
        to: details.to,
        label: details.label,
      };

      if (details.variant === 'query-name') {
        setQueryPicker(picker);
        return;
      }

      if (details.variant === 'budget-dimension') {
        setDimensionPicker(picker);
        return;
      }

      if (details.variant === 'budget-category-list') {
        setCategoryPicker({
          ...picker,
          selectedCategoryIds:
            details.categories?.map(category => category.id) ?? [],
        });
        return;
      }

      if (details.variant === 'budget-timeframe') {
        const parsed = parseMonthYear(details.label);
        setTimeframePicker({
          ...picker,
          month: parsed?.month ?? getCurrentMonth(),
          format: parsed?.format ?? 'year-month',
        });
      }
    },
    [closeBadgePickers],
  );

  const replaceBadgeValue = useCallback(
    (picker: BadgePickerState, value: string) => {
      const replacement = `"${value}"`;
      picker.view.dispatch({
        changes: {
          from: picker.from,
          to: picker.to,
          insert: replacement,
        },
        selection: { anchor: picker.from + replacement.length },
      });
      suppressBadgePickerUntilRef.current = Date.now() + 300;
      picker.view.focus();
      closeBadgePickers();
    },
    [closeBadgePickers],
  );

  const applyTimeframePickerValue = useCallback(
    (selectedDate: string) => {
      if (!timeframePicker) {
        return;
      }

      replaceBadgeValue(
        timeframePicker,
        formatMonthYear(selectedDate.slice(0, 7), timeframePicker.format),
      );
    },
    [replaceBadgeValue, timeframePicker],
  );

  const toggleCategoryPickerValue = useCallback((categoryId: string) => {
    setCategoryPicker(currentPicker => {
      if (!currentPicker) {
        return currentPicker;
      }

      const isSelected = currentPicker.selectedCategoryIds.includes(categoryId);
      return {
        ...currentPicker,
        selectedCategoryIds: isSelected
          ? currentPicker.selectedCategoryIds.filter(id => id !== categoryId)
          : [...currentPicker.selectedCategoryIds, categoryId],
      };
    });
  }, []);

  const applyCategoryPickerValue = useCallback(() => {
    if (!categoryPicker) {
      return;
    }

    replaceBadgeValue(
      categoryPicker,
      categoryPicker.selectedCategoryIds.join(', '),
    );
  }, [categoryPicker, replaceBadgeValue]);

  useEffect(() => {
    if (
      !queryPicker &&
      !dimensionPicker &&
      !timeframePicker &&
      !categoryPicker
    ) {
      return;
    }

    const onMouseDown = (event: MouseEvent) => {
      const target = event.target;
      if (
        target instanceof Node &&
        badgePickerPopoverRef.current?.contains(target)
      ) {
        return;
      }

      if (categoryPicker) {
        applyCategoryPickerValue();
      } else {
        closeBadgePickers();
      }
    };

    document.addEventListener('mousedown', onMouseDown, true);
    return () => document.removeEventListener('mousedown', onMouseDown, true);
  }, [
    applyCategoryPickerValue,
    categoryPicker,
    closeBadgePickers,
    dimensionPicker,
    queryPicker,
    timeframePicker,
  ]);

  useEffect(() => {
    if (
      !queryPicker &&
      !dimensionPicker &&
      !timeframePicker &&
      !categoryPicker
    ) {
      return;
    }

    const onKeyDown = (event: KeyboardEvent) => {
      if (event.key === 'Escape') {
        event.preventDefault();
        closeBadgePickers();
        (
          queryPicker ??
          dimensionPicker ??
          timeframePicker ??
          categoryPicker
        )?.view.focus();
      }
    };

    document.addEventListener('keydown', onKeyDown, true);
    return () => document.removeEventListener('keydown', onKeyDown, true);
  }, [
    closeBadgePickers,
    categoryPicker,
    dimensionPicker,
    queryPicker,
    timeframePicker,
  ]);

  const extensions = useMemo(
    () => [
      ...(singleLine
        ? [
            EditorState.transactionFilter.of(tr =>
              tr.newDoc.lines > 1
                ? [
                    tr,
                    {
                      changes: {
                        from: 0,
                        to: tr.newDoc.length,
                        insert: tr.newDoc.sliceString(0, undefined, ' '),
                      },
                      sequential: true,
                    },
                  ]
                : [tr],
            ),
          ]
        : []),
      ...excelFormulaExtension(
        mode,
        queries,
        isDarkTheme,
        variables,
        openBadgePicker,
        categoryBadges,
      ),
      EditorView.lineWrapping,
      EditorView.editable.of(!disabled),
      // Must come late + highest precedence so Tab accepts completion when the popup is open
      autocompleteTabAcceptHighest,
    ],
    [
      mode,
      queries,
      isDarkTheme,
      disabled,
      singleLine,
      variables,
      categoryBadges,
      openBadgePicker,
    ],
  );

  const codeMirrorTheme: ReactCodeMirrorProps['theme'] = isDarkTheme
    ? 'dark'
    : 'light';

  return (
    <>
      <CodeMirror
        value={value}
        height={height}
        theme={codeMirrorTheme}
        extensions={extensions}
        onChange={onChange}
        editable={!disabled}
        basicSetup={{
          lineNumbers: showLineNumbers,
          foldGutter: false,
          highlightActiveLine: true,
          highlightActiveLineGutter: false,
        }}
        style={{
          fontSize: '14px',
          border: 'none',
        }}
      />
      {queryPicker && queries && (
        <BadgeMenuPopover
          anchorRect={queryPicker.anchorRect}
          minWidth={240}
          popoverRef={badgePickerPopoverRef}
        >
          {Object.keys(queries).map(queryName => (
            <BadgeMenuButton
              key={queryName}
              selected={queryName === queryPicker.label}
              onClick={() => replaceBadgeValue(queryPicker, queryName)}
            >
              {queryName}
            </BadgeMenuButton>
          ))}
        </BadgeMenuPopover>
      )}
      {dimensionPicker && (
        <BadgeMenuPopover
          anchorRect={dimensionPicker.anchorRect}
          minWidth={180}
          popoverRef={badgePickerPopoverRef}
        >
          {budgetQueryDimensions.map(dimension => (
            <BadgeMenuButton
              key={dimension}
              selected={dimension === dimensionPicker.label}
              onClick={() => replaceBadgeValue(dimensionPicker, dimension)}
            >
              {dimension}
            </BadgeMenuButton>
          ))}
        </BadgeMenuPopover>
      )}
      {categoryPicker && categoryBadges && (
        <BadgeMenuPopover
          anchorRect={categoryPicker.anchorRect}
          minWidth={280}
          popoverRef={badgePickerPopoverRef}
          scrollable={false}
        >
          <div
            style={{
              maxHeight: 220,
              overflowY: 'auto',
              padding: 4,
            }}
          >
            {Object.entries(categoryBadges).map(([categoryId, label]) => (
              <BadgeMenuButton
                key={categoryId}
                selected={categoryPicker.selectedCategoryIds.includes(
                  categoryId,
                )}
                onClick={() => toggleCategoryPickerValue(categoryId)}
              >
                {label}
              </BadgeMenuButton>
            ))}
          </div>
          <div
            style={{
              display: 'flex',
              gap: 6,
              justifyContent: 'flex-end',
              padding: '6px 4px 2px',
              margin: '4px 4px 0',
            }}
          >
            <button
              type="button"
              onClick={closeBadgePickers}
              style={pickerActionButtonStyle}
            >
              <Trans>Cancel</Trans>
            </button>
            <button
              type="button"
              onClick={applyCategoryPickerValue}
              style={{
                ...pickerActionButtonStyle,
                background: theme.buttonPrimaryBackground,
                color: theme.buttonPrimaryText,
              }}
            >
              <Trans>Apply</Trans>
            </button>
          </div>
        </BadgeMenuPopover>
      )}
      {timeframePicker && (
        <div
          ref={badgePickerPopoverRef}
          style={{
            ...styles.popover,
            position: 'fixed',
            zIndex: 10000,
            top: timeframePicker.anchorRect.bottom + 4,
            left: Math.min(
              timeframePicker.anchorRect.left,
              window.innerWidth - TIMEFRAME_PICKER_WIDTH,
            ),
            // Definite width required by the embedded calendar (see DateSelect)
            width: TIMEFRAME_PICKER_WIDTH,
          }}
          onMouseDown={event => {
            event.stopPropagation();
          }}
          onClick={event => event.stopPropagation()}
        >
          <DateSelect
            value={`${timeframePicker.month}-01`}
            dateFormat={dateFormat}
            embedded
            isOpen
            onSelect={applyTimeframePickerValue}
          />
        </div>
      )}
    </>
  );
}

const TIMEFRAME_PICKER_WIDTH = 260;

const pickerActionButtonStyle = {
  border: 0,
  borderRadius: 4,
  padding: '5px 8px',
  background: theme.buttonNormalBackground,
  color: theme.buttonNormalText,
  fontSize: 12,
  cursor: 'pointer',
};

function BadgeMenuPopover({
  anchorRect,
  minWidth,
  popoverRef,
  scrollable = true,
  children,
}: {
  anchorRect: DOMRect;
  minWidth: number;
  popoverRef?: RefObject<HTMLDivElement | null>;
  scrollable?: boolean;
  children: ReactNode;
}) {
  return (
    <div
      ref={popoverRef}
      style={{
        ...styles.popover,
        position: 'fixed',
        zIndex: 10000,
        top: anchorRect.bottom + 4,
        left: Math.min(anchorRect.left, window.innerWidth - minWidth - 20),
        minWidth,
        maxWidth: 320,
        maxHeight: 260,
        overflowY: scrollable ? 'auto' : 'hidden',
        padding: scrollable ? 4 : 0,
      }}
      onMouseDown={event => {
        event.stopPropagation();
      }}
      onClick={event => event.stopPropagation()}
    >
      {children}
    </div>
  );
}

function BadgeMenuButton({
  selected,
  onClick,
  children,
}: {
  selected: boolean;
  onClick: () => void;
  children: ReactNode;
}) {
  return (
    <button
      type="button"
      onClick={onClick}
      style={{
        display: 'block',
        width: '100%',
        border: 0,
        borderRadius: 4,
        padding: '7px 8px',
        background: selected ? theme.menuItemBackgroundHover : 'transparent',
        color: theme.pageText,
        textAlign: 'left',
        fontSize: 13,
        cursor: 'pointer',
      }}
    >
      {children}
    </button>
  );
}