src/pages/meetings/schedules/useWeeklySchedules.tsx (1)

18-26: Consider adding 'scheduleType' to the dependency array of useMemo

The useMemo hook depends on scheduleType, but the dependency array is empty. To ensure value updates when scheduleType changes, include it in the dependency array.

Apply this diff to address the issue:

 const value = useMemo(() => {
   if (!scheduleType) return 0;

   if (scheduleType === 'midweek') return 0;
   if (scheduleType === 'weekend') return 1;
   if (scheduleType === 'outgoing') return 2;
- }, []);
+ }, [scheduleType]);

src/services/app/sources.ts (1)

107-113: Refactor repeated logic for 'assType' assignment

The conditional blocks assigning assType based on source_lang, obj.weekOf, and assType are duplicated. Consider extracting this logic into a helper function to reduce code duplication and improve maintainability.

Example refactor:

+ const adjustAssType = (assType: number): number => {
+   if (source_lang === 'TG' && obj.weekOf >= '2024/01/01' && assType === 102) {
+     return 124;
+   }
+   return assType;
+ };
+
 // Within each assignment block
 assType =
   assTypeList.find((type) => type.label === src.mwb_ayf_part1_type)?.value || 127;

- if (
-   source_lang === 'TG' &&
-   obj.weekOf >= '2024/01/01' &&
-   assType === 102
- ) {
-   assType = 124;
- }
+ assType = adjustAssType(assType);

Also applies to: 127-133, 148-154, 169-175

src/features/congregation/settings/import_export/index.types.ts (1)

1-4: Add JSDoc documentation for the type definition.

The type definition is well-structured, but adding documentation would improve maintainability.

+/**
+ * Props type for the ImportExport component
+ * @property open - Controls the visibility of the import/export dialog
+ * @property onClose - Callback function to handle dialog close action
+ */
 export type ImportExportType = {
   open: boolean;
   onClose: VoidFunction;
 };

src/pages/congregation/settings/useCongregationSettings.tsx (1)

6-8: Consider memoizing handler functions.

The handler functions could be memoized using useCallback to prevent unnecessary re-renders in child components that receive these functions as props.

-  const handleOpenExchange = () => setIsDataExchangeOpen(true);
+  const handleOpenExchange = useCallback(() => setIsDataExchangeOpen(true), []);

-  const handleCloseExchange = () => setIsDataExchangeOpen(false);
+  const handleCloseExchange = useCallback(() => setIsDataExchangeOpen(false), []);

Don't forget to import useCallback:

-import { useState } from 'react';
+import { useState, useCallback } from 'react';

src/features/congregation/settings/import_export/useImportExport.tsx (1)

15-15: Define translation keys as constants.

Hardcoded translation keys can lead to maintenance issues. Consider defining them as constants.

+const TRANSLATION_KEYS = {
+  EXPORT: 'tr_export',
+  IMPORT: 'tr_import',
+} as const;

 const tabs = useMemo(() => {
   return [
     {
-      label: t('tr_export'),
+      label: t(TRANSLATION_KEYS.EXPORT),
       component: Export,
     },
     {
-      label: t('tr_import'),
+      label: t(TRANSLATION_KEYS.IMPORT),
       component: Import,
     },
   ];
 }, [t, onClose]);

Also applies to: 19-19

src/features/congregation/settings/import_export/index.tsx (2)

15-15: Consider using theme spacing instead of hardcoded padding.

Replace the hardcoded padding with theme spacing for consistency and maintainability.

-<Dialog onClose={props.onClose} open={props.open} sx={{ padding: '24px' }}>
+<Dialog onClose={props.onClose} open={props.open} sx={{ padding: (theme) => theme.spacing(3) }}>

---

19-21: Consider using an enum or constant for tab values.

Using magic numbers (0) for tab comparison makes the code less maintainable. Consider defining an enum for tab values.

+enum TabValue {
+  EXPORT = 0,
+  IMPORT = 1,
+}

// Then use it in the comparison
-{value === 0 ? t('tr_exportDesc') : t('tr_importDesc')}
+{value === TabValue.EXPORT ? t('tr_exportDesc') : t('tr_importDesc')}

src/features/congregation/settings/import_export/import/useImport.tsx (1)

36-42: Consider extracting configuration constants.

File size and type restrictions should be defined as named constants for better maintainability.

+const MAX_FILE_SIZE = 20 * 1024 * 1024; // 20MB
+const ACCEPTED_FILE_TYPES = { 'text/json': ['.json'] };
+const MAX_FILES = 1;

const { getRootProps, getInputProps } = useDropzone({
  onDrop,
-  accept: { 'text/json': ['.json'] },
-  maxFiles: 1,
-  maxSize: 20971520,
+  accept: ACCEPTED_FILE_TYPES,
+  maxFiles: MAX_FILES,
+  maxSize: MAX_FILE_SIZE,
  multiple: false,
});

src/pages/congregation/settings/index.tsx (1)

23-25: Consider lazy loading the ImportExport dialog.

Since the ImportExport dialog is only shown when needed, consider lazy loading it to improve initial bundle size and page load performance.

-import ImportExport from '@features/congregation/settings/import_export';
+const ImportExport = React.lazy(() => import('@features/congregation/settings/import_export'));

// In the render:
      {isDataExchangeOpen && (
+       <React.Suspense fallback={<CircularProgress />}>
          <ImportExport open={isDataExchangeOpen} onClose={handleCloseExchange} />
+       </React.Suspense>
      )}

src/services/dexie/weekType.ts (1)

13-17: Consider enhancing language fallback mechanism

The current implementation provides basic language fallback to English, but could be more robust by:

1. Validating the language code format
2. Using a constant for the default language
3. Handling potential localStorage errors

-const language = localStorage.getItem('ui_lang') || 'en';
-const languages = [language];
-
-if (!languages.includes('en')) languages.push('en');
+const DEFAULT_LANGUAGE = 'en';
+let language;
+try {
+  language = localStorage.getItem('ui_lang') || DEFAULT_LANGUAGE;
+  // Basic validation of language code format
+  if (!/^[a-z]{2}(-[A-Z]{2})?$/.test(language)) {
+    language = DEFAULT_LANGUAGE;
+  }
+} catch (error) {
+  language = DEFAULT_LANGUAGE;
+}
+const languages = [language];
+if (language !== DEFAULT_LANGUAGE) {
+  languages.push(DEFAULT_LANGUAGE);
+}

src/components/icons/IconImportExport.tsx (2)

3-17: Props interface looks good, consider minor improvements

The props interface is well-defined with appropriate types. Consider these minor enhancements:

1. Add prop documentation
2. Consider making className concatenation more robust

 type IconProps = {
+  /** Custom color for the icon */
   color?: string;
+  /** Width in pixels */
   width?: number;
+  /** Height in pixels */
   height?: number;
+  /** MUI System props */
   sx?: SxProps<Theme>;
+  /** Additional CSS class names */
   className?: string;
 };

---

19-49: Improve className handling and SVG optimization

The component implementation is solid, but could benefit from:

1. More robust className handling
2. SVG optimization

-      className={`organized-icon-import-export ${className}`}
+      className={`organized-icon-import-export${className ? ` ${className}` : ''}`}
       sx={{ width: `${width}px`, height: `${height}px`, ...sx }}
     >

Consider running the SVG through an optimizer to reduce the path complexity while maintaining visual quality.

src/components/icons/IconImportJson.tsx (1)

12-12: Standardize color handling across icon components

The color handling differs between IconImportJson and IconImportExport:

• IconImportExport uses a default color prop
• IconImportJson falls back to CSS variable

Standardize the approach:

-  color,
+  color = 'var(--accent-dark)',
   width = 24,
   // ...
     <path
-      fill={color || 'var(--accent-dark)'}
+      fill={color}

Also applies to: 44-44

src/components/icons/IconBackupOrganized.tsx (1)

19-22: Consider memoizing className concatenation.

The className template literal is recreated on every render. Consider memoizing it with useMemo for better performance in high-frequency updates.

-      className={`organized-icon-backup-organized ${className}`}
+      className={useMemo(() => `organized-icon-backup-organized ${className || ''}`, [className])}

src/features/congregation/settings/import_export/export/useExport.tsx (1)

68-68: Consider moving filter logic to the selector level.

The persons filter could be moved to a Recoil selector for better performance and reusability.

-          persons: persons.filter((record) => !record._deleted.value),
+          persons: useRecoilValue(personsActiveState), // Create a new selector

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Verify that 'obj.weekOf' and 'mondayDate' have consistent formats.

# Expected format: 'yyyy/MM/dd'

echo "obj.weekOf sample value:"
grep -r "obj.weekOf =" src/ | head -n 1

echo "Format of 'mondayDate':"
grep -r "formatDate(" src/ | grep "mondayDate" | head -n 1

#!/bin/bash
# Check the implementation of formatDate and getWeekDate functions
ast-grep --pattern 'function formatDate($_) { $$$ }'
ast-grep --pattern 'function getWeekDate($_) { $$$ }'

# Check how weekOf is being used in the codebase
rg "weekOf" -A 2

# Check the type definitions related to weekOf
rg "weekOf.*:" -A 1

#!/bin/bash
# Search for getWeekDate implementation
rg "getWeekDate" -B 2 -A 5

# Search for formatDate implementation
rg "formatDate" -B 2 -A 5

# Check how obj.weekOf is being used in comparison
rg "obj\.weekOf.*===" -A 2
rg "obj\.weekOf.*>=" -A 2

-  const { t } = useAppTranslation();
+  const { t, ready } = useAppTranslation();
+  if (!ready) {
+    return { tabs: [], value: 0, handleTabChange: () => {} };
+  }

#!/bin/bash
# Description: Verify translation keys exist in translation files

# Find all translation files
fd -e json -e ts --full-path "translations|i18n" | while read -r file; do
  echo "Checking $file for translation keys..."
  # Search for translation keys
  rg -q "tr_(normalWeek|circuitOverseerWeek|assemblyWeek|conventionWeek|memorialWeek|specialTalkWeek|noMeeting)" "$file" || echo "Missing keys in $file"
done

#!/bin/bash
# First, let's find all JSON files that might contain translations
fd -e json | while read -r file; do
  echo "=== Checking $file ==="
  # Look for any of these translation keys
  rg "tr_(normalWeek|circuitOverseerWeek|assemblyWeek|conventionWeek|memorialWeek|specialTalkWeek|noMeeting)" "$file" || echo "No matches found"
done

#!/bin/bash
# Description: Check the structure and usage of AYF type configurations

# Search for type property usage in AYF parts
ast-grep --pattern 'midweek_meeting: {
  $$$
  ayf_part1: {
    $$$
    type: $_
    $$$
  }
  $$$
}'

# Search for any other restore operations that might need similar type preservation
rg -A 5 "midweek_meeting.*type"