add eslint / prettier

src/hooks/useCooldownTimer.ts

@@ -23,6 +23,6 @@ export function useCooldownTimer(seconds = 0, enabled = true) {
 
   return {
     cooldown,
-    startCooldown
+    startCooldown,
   };
 }

src/hooks/useEditableForm.ts

@@ -10,7 +10,7 @@ type UseEditableFormOptions<TValues> = {
 
 export function useEditableForm<TValues extends Record<string, string>>({
   initialValues,
-  validate
+  validate,
 }: UseEditableFormOptions<TValues>) {
   const [isEditing, setIsEditing] = useState(false);
 
@@ -23,30 +23,42 @@ export function useEditableForm<TValues extends Record<string, string>>({
     validateAll,
     setFieldError,
     setErrors,
-    clearErrors
+    clearErrors,
   } = useValidatedFields({
     initialValues,
-    validate
+    validate,
   });
 
-  const startEditing = useCallback((sourceValues: TValues) => {
-    setValues(sourceValues, { validate: true });
-    setIsEditing(true);
-  }, [setValues]);
+  const startEditing = useCallback(
+    (sourceValues: TValues) => {
+      setValues(sourceValues, { validate: true });
+      setIsEditing(true);
+    },
+    [setValues],
+  );
 
-  const discardChanges = useCallback((sourceValues: TValues) => {
-    setValues(sourceValues, { clearErrors: true });
-    setIsEditing(false);
-  }, [setValues]);
+  const discardChanges = useCallback(
+    (sourceValues: TValues) => {
+      setValues(sourceValues, { clearErrors: true });
+      setIsEditing(false);
+    },
+    [setValues],
+  );
 
-  const loadFromSource = useCallback((sourceValues: TValues) => {
-    setValues(sourceValues, { clearErrors: true });
-  }, [setValues]);
+  const loadFromSource = useCallback(
+    (sourceValues: TValues) => {
+      setValues(sourceValues, { clearErrors: true });
+    },
+    [setValues],
+  );
 
-  const commitSaved = useCallback((sourceValues: TValues) => {
-    setValues(sourceValues, { clearErrors: true });
-    setIsEditing(false);
-  }, [setValues]);
+  const commitSaved = useCallback(
+    (sourceValues: TValues) => {
+      setValues(sourceValues, { clearErrors: true });
+      setIsEditing(false);
+    },
+    [setValues],
+  );
 
   return {
     values,
@@ -63,6 +75,6 @@ export function useEditableForm<TValues extends Record<string, string>>({
     discardChanges,
     loadFromSource,
     commitSaved,
-    setIsEditing
+    setIsEditing,
   };
 }

src/hooks/usePaginatedResource.ts

@@ -9,7 +9,12 @@ type PaginatedResourceResponse<TItem> = {
 };
 
 type UsePaginatedResourceOptions<TItem> = {
-  load: (params: { q: string; page: number; pageSize: number; sort?: string }) => Promise<PaginatedResourceResponse<TItem>>;
+  load: (params: {
+    q: string;
+    page: number;
+    pageSize: number;
+    sort?: string;
+  }) => Promise<PaginatedResourceResponse<TItem>>;
   sort?: string;
   debounceMs?: number;
   initialQuery?: string;
@@ -23,7 +28,7 @@ export function usePaginatedResource<TItem>({
   debounceMs = 250,
   initialQuery = '',
   initialPage = 1,
-  initialPageSize = 10
+  initialPageSize = 10,
 }: UsePaginatedResourceOptions<TItem>) {
   const [items, setItems] = useState<TItem[]>([]);
   const [q, setQ] = useState(initialQuery);
@@ -46,7 +51,7 @@ export function usePaginatedResource<TItem>({
             q,
             page,
             pageSize,
-            sort
+            sort,
           });
 
           if (cancelled) {
@@ -97,6 +102,6 @@ export function usePaginatedResource<TItem>({
     isLoading,
     setQuery,
     setPage,
-    setPageSize: setPageSizeAndResetPage
+    setPageSize: setPageSizeAndResetPage,
   };
 }

src/hooks/useSorting.ts

@@ -31,32 +31,35 @@ export function useSorting(defaultSort?: SortState | null): UseSortingResult {
 
   const activeSort = overrideSort ?? defaultSort ?? null;
 
-  const toggleSort = useCallback((field: string) => {
-    setOverrideSort((previousOverride) => {
-      const baselineSort = defaultSort ?? null;
-      const currentSort = previousOverride ?? baselineSort;
+  const toggleSort = useCallback(
+    (field: string) => {
+      setOverrideSort((previousOverride) => {
+        const baselineSort = defaultSort ?? null;
+        const currentSort = previousOverride ?? baselineSort;
 
-      if (!currentSort || currentSort.field !== field) {
-        return { field, direction: 'asc' };
-      }
-
-      if (baselineSort && baselineSort.field === field) {
-        if (previousOverride == null) {
-          return { field, direction: invertDirection(baselineSort.direction) };
+        if (!currentSort || currentSort.field !== field) {
+          return { field, direction: 'asc' };
         }
-        if (previousOverride.direction === baselineSort.direction) {
-          return { field, direction: invertDirection(baselineSort.direction) };
+
+        if (baselineSort && baselineSort.field === field) {
+          if (previousOverride == null) {
+            return { field, direction: invertDirection(baselineSort.direction) };
+          }
+          if (previousOverride.direction === baselineSort.direction) {
+            return { field, direction: invertDirection(baselineSort.direction) };
+          }
+          return null;
         }
-        return null;
-      }
 
-      if (previousOverride == null || previousOverride.direction === 'desc') {
-        return null;
-      }
+        if (previousOverride == null || previousOverride.direction === 'desc') {
+          return null;
+        }
 
-      return { field, direction: 'desc' };
-    });
-  }, [defaultSort]);
+        return { field, direction: 'desc' };
+      });
+    },
+    [defaultSort],
+  );
 
   const setSort = useCallback((next: SortState | null) => {
     setOverrideSort(next);
@@ -73,6 +76,6 @@ export function useSorting(defaultSort?: SortState | null): UseSortingResult {
     sortParam,
     toggleSort,
     setSort,
-    resetSort
+    resetSort,
   };
 }

src/hooks/useSubmitState.ts

@@ -26,6 +26,6 @@ export function useSubmitState<TStatus = string | null>(initialStatus: TStatus)
     finishSubmitting,
     setSubmitError,
     setStatus,
-    clearFeedback
+    clearFeedback,
   };
 }

src/hooks/useValidatedFields.ts

@@ -28,7 +28,7 @@ function hasErrors<TValues>(errors: FieldErrors<TValues>): boolean {
 
 function pickTouchedErrors<TValues>(
   errors: FieldErrors<TValues>,
-  touched: TouchedFields<TValues>
+  touched: TouchedFields<TValues>,
 ): FieldErrors<TValues> {
   const next: FieldErrors<TValues> = {};
 
@@ -53,75 +53,80 @@ function touchAll<TValues extends Record<string, string>>(values: TValues): Touc
 
 export function useValidatedFields<TValues extends Record<string, string>>({
   initialValues,
-  validate
+  validate,
 }: UseValidatedFieldsOptions<TValues>) {
   const [values, setValues] = useState<TValues>(initialValues);
   const [allErrors, setAllErrors] = useState<FieldErrors<TValues>>(() => validate(initialValues));
   const [touched, setTouched] = useState<TouchedFields<TValues>>({});
 
-  const updateValues = useCallback((nextValues: TValues, options: SetValuesOptions = {}) => {
-    const { validate: shouldValidate = false, clearErrors = false } = options;
-    setValues(nextValues);
+  const updateValues = useCallback(
+    (nextValues: TValues, options: SetValuesOptions = {}) => {
+      const { validate: shouldValidate = false, clearErrors = false } = options;
+      setValues(nextValues);
 
-    if (shouldValidate || clearErrors) {
-      setAllErrors(validate(nextValues));
-    }
-
-    if (clearErrors) {
-      setTouched({});
-    }
-  }, [validate]);
-
-  const setFieldValue = useCallback(<K extends keyof TValues>(
-    key: K,
-    value: TValues[K],
-    options: SetFieldValueOptions = {}
-  ) => {
-    const { validate: shouldValidate = true, touch = true } = options;
-
-    if (touch) {
-      setTouched((current) => ({
-        ...current,
-        [key]: true
-      }));
-    }
-
-    setValues((current) => {
-      const nextValues = {
-        ...current,
-        [key]: value
-      };
-
-      if (shouldValidate) {
+      if (shouldValidate || clearErrors) {
         setAllErrors(validate(nextValues));
       }
 
-      return nextValues;
-    });
-  }, [validate]);
+      if (clearErrors) {
+        setTouched({});
+      }
+    },
+    [validate],
+  );
 
-  const validateAll = useCallback((options: ValidateAllOptions = {}) => {
-    const { touchAll: shouldTouchAll = true } = options;
-    const nextErrors = validate(values);
+  const setFieldValue = useCallback(
+    <K extends keyof TValues>(key: K, value: TValues[K], options: SetFieldValueOptions = {}) => {
+      const { validate: shouldValidate = true, touch = true } = options;
 
-    setAllErrors(nextErrors);
+      if (touch) {
+        setTouched((current) => ({
+          ...current,
+          [key]: true,
+        }));
+      }
 
-    if (shouldTouchAll) {
-      setTouched(touchAll(values));
-    }
+      setValues((current) => {
+        const nextValues = {
+          ...current,
+          [key]: value,
+        };
 
-    return nextErrors;
-  }, [validate, values]);
+        if (shouldValidate) {
+          setAllErrors(validate(nextValues));
+        }
+
+        return nextValues;
+      });
+    },
+    [validate],
+  );
+
+  const validateAll = useCallback(
+    (options: ValidateAllOptions = {}) => {
+      const { touchAll: shouldTouchAll = true } = options;
+      const nextErrors = validate(values);
+
+      setAllErrors(nextErrors);
+
+      if (shouldTouchAll) {
+        setTouched(touchAll(values));
+      }
+
+      return nextErrors;
+    },
+    [validate, values],
+  );
 
   const setFieldError = useCallback(<K extends keyof TValues>(key: K, message?: string) => {
     setTouched((current) => ({
       ...current,
-      [key]: true
+      [key]: true,
     }));
 
     setAllErrors((current) => ({
       ...current,
-      [key]: message
+      [key]: message,
     }));
   }, []);
 
@@ -136,7 +141,7 @@ export function useValidatedFields<TValues extends Record<string, string>>({
 
     setTouched((current) => ({
       ...current,
-      ...nextTouched
+      ...nextTouched,
     }));
     setAllErrors(nextErrors);
   }, []);
@@ -161,6 +166,6 @@ export function useValidatedFields<TValues extends Record<string, string>>({
     validateAll,
     setFieldError,
     setErrors: updateErrors,
-    clearErrors
+    clearErrors,
   };
 }