github-issue-tower-defence-management 1.181.1 → 1.183.0

package/src/adapter/entry-points/console/ui/src/features/console/components/layout/ConsoleTimerSettingsModalDialog.tsx

@@ -0,0 +1,118 @@
+export type ConsoleTimerSettingsModalDialogProps = {
+  isOpen: boolean;
+  timerMode: boolean;
+  projectMinutes: Record<string, number>;
+  pjcodes: string[];
+  isLoadingPjcodes: boolean;
+  onOpen: () => void;
+  onToggleTimerMode: (enabled: boolean) => void;
+  onChangeMinutes: (pjcode: string, minutes: number) => void;
+  onSave: () => void;
+  onClose: () => void;
+};
+
+export const ConsoleTimerSettingsModalDialog = ({
+  isOpen,
+  timerMode,
+  projectMinutes,
+  pjcodes,
+  isLoadingPjcodes,
+  onOpen,
+  onToggleTimerMode,
+  onChangeMinutes,
+  onSave,
+  onClose,
+}: ConsoleTimerSettingsModalDialogProps) => {
+  return (
+    <>
+      <button
+        type="button"
+        className="console-timer-settings-button"
+        aria-label="Console Settings"
+        aria-haspopup="dialog"
+        aria-expanded={isOpen}
+        onClick={onOpen}
+      >
+        ⚙
+      </button>
+      {isOpen && (
+        <div
+          className="console-timer-settings-dialog"
+          role="dialog"
+          aria-modal="true"
+          aria-label="Console Settings"
+        >
+          <button
+            type="button"
+            className="console-timer-settings-backdrop"
+            aria-label="Close settings"
+            onClick={onClose}
+          />
+          <div className="console-timer-settings-dialog-inner">
+            <h2 className="console-timer-settings-title">Console Settings</h2>
+            <div className="console-timer-settings-row">
+              <label
+                className="console-timer-settings-label"
+                htmlFor="timer-mode-toggle"
+              >
+                Timer Mode
+              </label>
+              <input
+                id="timer-mode-toggle"
+                type="checkbox"
+                checked={timerMode}
+                onChange={(e) => onToggleTimerMode(e.target.checked)}
+              />
+            </div>
+            {isLoadingPjcodes ? (
+              <div className="console-timer-settings-loading">
+                Loading projects...
+              </div>
+            ) : (
+              <ul className="console-timer-settings-project-list">
+                {pjcodes.map((pjcode) => (
+                  <li
+                    key={pjcode}
+                    className="console-timer-settings-project-row"
+                  >
+                    <label
+                      htmlFor={`timer-minutes-${pjcode}`}
+                      className="console-timer-settings-pjcode"
+                    >
+                      {pjcode}
+                    </label>
+                    <input
+                      id={`timer-minutes-${pjcode}`}
+                      type="number"
+                      min={0}
+                      value={projectMinutes[pjcode] ?? 0}
+                      onChange={(e) =>
+                        onChangeMinutes(
+                          pjcode,
+                          Math.max(0, parseInt(e.target.value, 10) || 0),
+                        )
+                      }
+                      className="console-timer-settings-minutes-input"
+                    />
+                    <span className="console-timer-settings-minutes-label">
+                      {(projectMinutes[pjcode] ?? 0) === 0 ? 'Skip' : 'min'}
+                    </span>
+                  </li>
+                ))}
+              </ul>
+            )}
+            <div className="console-timer-settings-actions">
+              <button
+                type="button"
+                className="console-timer-settings-save"
+                onClick={onSave}
+              >
+                Save and Close
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </>
+  );
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleProjectList.test.ts

@@ -0,0 +1,74 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useConsoleProjectList } from './useConsoleProjectList';
+
+describe('useConsoleProjectList', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('starts in loading state with empty pjcodes and no error', () => {
+    global.fetch = jest.fn(
+      () => new Promise(() => undefined),
+    ) as unknown as typeof fetch;
+
+    const { result } = renderHook(() => useConsoleProjectList());
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.pjcodes).toEqual([]);
+    expect(result.current.error).toBeNull();
+  });
+
+  it('populates pjcodes and clears loading state when fetchProjectList resolves', async () => {
+    global.fetch = jest.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ pjcodes: ['acme', 'beta'] }),
+    })) as unknown as typeof fetch;
+
+    const { result } = renderHook(() => useConsoleProjectList());
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+    expect(result.current.pjcodes).toEqual(['acme', 'beta']);
+    expect(result.current.error).toBeNull();
+  });
+
+  it('sets error and clears loading state when fetchProjectList rejects', async () => {
+    global.fetch = jest.fn(async () => ({
+      ok: false,
+      status: 401,
+      json: async () => ({}),
+    })) as unknown as typeof fetch;
+
+    const { result } = renderHook(() => useConsoleProjectList());
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+    expect(result.current.error).toBeInstanceOf(Error);
+    expect(result.current.error?.message).toBe('HTTP 401');
+    expect(result.current.pjcodes).toEqual([]);
+  });
+
+  it('skips state update when component unmounts before fetch resolves', async () => {
+    let resolveResponse!: (value: unknown) => void;
+    const pendingFetch = new Promise<unknown>((resolve) => {
+      resolveResponse = resolve;
+    });
+    global.fetch = jest.fn(() => pendingFetch) as unknown as typeof fetch;
+
+    const { result, unmount } = renderHook(() => useConsoleProjectList());
+    expect(result.current.isLoading).toBe(true);
+
+    unmount();
+
+    await act(async () => {
+      resolveResponse({
+        ok: true,
+        status: 200,
+        json: async () => ({ pjcodes: ['acme'] }),
+      });
+    });
+
+    expect(result.current.pjcodes).toEqual([]);
+    expect(result.current.isLoading).toBe(true);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleProjectList.ts

@@ -0,0 +1,40 @@
+import { useEffect, useState } from 'react';
+import { fetchProjectList } from '../lib/consoleApi';
+
+export type ConsoleProjectListState = {
+  pjcodes: string[];
+  isLoading: boolean;
+  error: Error | null;
+};
+
+export const useConsoleProjectList = (): ConsoleProjectListState => {
+  const [pjcodes, setPjcodes] = useState<string[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    setIsLoading(true);
+    setError(null);
+
+    fetchProjectList()
+      .then((list) => {
+        if (!cancelled) {
+          setPjcodes(list);
+          setIsLoading(false);
+        }
+      })
+      .catch((cause: unknown) => {
+        if (!cancelled) {
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setIsLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  return { pjcodes, isLoading, error };
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleProjectTimer.test.ts

@@ -0,0 +1,59 @@
+import { renderHook } from '@testing-library/react';
+import { useConsoleProjectTimer } from './useConsoleProjectTimer';
+
+describe('useConsoleProjectTimer', () => {
+  beforeEach(() => {
+    jest.spyOn(Date, 'now');
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns false before the configured minutes have elapsed', () => {
+    (Date.now as jest.Mock).mockReturnValue(1000);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(1000 + 4 * 60 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(false);
+  });
+
+  it('returns true once the configured minutes have elapsed', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(5 * 60 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(true);
+  });
+
+  it('returns true after more than the configured minutes have elapsed', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(10 * 60 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(true);
+  });
+
+  it('returns false when minutes is 0 regardless of elapsed time', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(10 * 60 * 1000);
+    expect(result.current.isTimerExpired(0)).toBe(false);
+  });
+
+  it('returns false when minutes is negative', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result } = renderHook(() => useConsoleProjectTimer('alpha'));
+    (Date.now as jest.Mock).mockReturnValue(10 * 60 * 1000);
+    expect(result.current.isTimerExpired(-1)).toBe(false);
+  });
+
+  it('resets the start time when pjcode changes', () => {
+    (Date.now as jest.Mock).mockReturnValue(0);
+    const { result, rerender } = renderHook(
+      ({ pjcode }: { pjcode: string | null }) => useConsoleProjectTimer(pjcode),
+      { initialProps: { pjcode: 'alpha' } },
+    );
+    (Date.now as jest.Mock).mockReturnValue(4 * 60 * 1000);
+    rerender({ pjcode: 'beta' });
+    (Date.now as jest.Mock).mockReturnValue(4 * 60 * 1000 + 30 * 1000);
+    expect(result.current.isTimerExpired(5)).toBe(false);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleProjectTimer.ts

@@ -0,0 +1,26 @@
+import { useCallback, useRef } from 'react';
+
+export type ConsoleProjectTimerState = {
+  isTimerExpired: (minutes: number) => boolean;
+};
+
+export const useConsoleProjectTimer = (
+  pjcode: string | null,
+): ConsoleProjectTimerState => {
+  const pjcodeRef = useRef(pjcode);
+  const startRef = useRef<number>(Date.now());
+
+  if (pjcodeRef.current !== pjcode) {
+    pjcodeRef.current = pjcode;
+    startRef.current = Date.now();
+  }
+
+  const isTimerExpired = useCallback((minutes: number): boolean => {
+    if (minutes <= 0) {
+      return false;
+    }
+    return Date.now() - startRef.current >= minutes * 60 * 1000;
+  }, []);
+
+  return { isTimerExpired };
+};

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleTimerSettings.test.ts

@@ -0,0 +1,110 @@
+import { act, renderHook } from '@testing-library/react';
+import { TIMER_SETTINGS_KEY } from '../logic/timerSettings';
+import { useConsoleTimerSettings } from './useConsoleTimerSettings';
+
+describe('useConsoleTimerSettings', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('initialises with timer mode off and empty project minutes when localStorage is empty', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    expect(result.current.timerMode).toBe(false);
+    expect(result.current.projectMinutes).toEqual({});
+    expect(result.current.isOpen).toBe(false);
+  });
+
+  it('openSettings resets draft to the current saved settings, not the previous draft', () => {
+    localStorage.setItem(
+      TIMER_SETTINGS_KEY,
+      JSON.stringify({ timerMode: true, projectMinutes: { acme: 30 } }),
+    );
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 99);
+    });
+    act(() => {
+      result.current.closeSettings();
+    });
+    act(() => {
+      result.current.openSettings();
+    });
+    expect(result.current.draftTimerMode).toBe(true);
+    expect(result.current.draftProjectMinutes).toEqual({ acme: 30 });
+  });
+
+  it('openSettings sets isOpen to true', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    expect(result.current.isOpen).toBe(true);
+  });
+
+  it('changeDraftMinutes mutates draft but does not change saved or localStorage', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 45);
+    });
+    expect(result.current.draftProjectMinutes).toEqual({ acme: 45 });
+    expect(result.current.projectMinutes).toEqual({});
+    expect(localStorage.getItem(TIMER_SETTINGS_KEY)).toBeNull();
+  });
+
+  it('saveSettings writes to localStorage with key tdpm-timer-settings and closes the dialog', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.toggleDraftTimerMode(true);
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 20);
+    });
+    act(() => {
+      result.current.saveSettings();
+    });
+    expect(result.current.isOpen).toBe(false);
+    const stored = localStorage.getItem(TIMER_SETTINGS_KEY);
+    expect(stored).not.toBeNull();
+    const parsed = JSON.parse(stored as string) as unknown;
+    expect(parsed).toEqual({ timerMode: true, projectMinutes: { acme: 20 } });
+    expect(result.current.timerMode).toBe(true);
+    expect(result.current.projectMinutes).toEqual({ acme: 20 });
+  });
+
+  it('closeSettings discards draft without writing to localStorage', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.changeDraftMinutes('acme', 60);
+    });
+    act(() => {
+      result.current.closeSettings();
+    });
+    expect(result.current.isOpen).toBe(false);
+    expect(localStorage.getItem(TIMER_SETTINGS_KEY)).toBeNull();
+    expect(result.current.projectMinutes).toEqual({});
+  });
+
+  it('toggleDraftTimerMode updates draftTimerMode without affecting saved timerMode', () => {
+    const { result } = renderHook(() => useConsoleTimerSettings());
+    act(() => {
+      result.current.openSettings();
+    });
+    act(() => {
+      result.current.toggleDraftTimerMode(true);
+    });
+    expect(result.current.draftTimerMode).toBe(true);
+    expect(result.current.timerMode).toBe(false);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleTimerSettings.ts

@@ -0,0 +1,70 @@
+import { useCallback, useState } from 'react';
+import {
+  readTimerSettings,
+  type TimerSettings,
+  writeTimerSettings,
+} from '../logic/timerSettings';
+
+export type ConsoleTimerSettingsState = {
+  timerMode: boolean;
+  projectMinutes: Record<string, number>;
+  isOpen: boolean;
+  draftTimerMode: boolean;
+  draftProjectMinutes: Record<string, number>;
+  openSettings: () => void;
+  closeSettings: () => void;
+  saveSettings: () => void;
+  toggleDraftTimerMode: (enabled: boolean) => void;
+  changeDraftMinutes: (pjcode: string, minutes: number) => void;
+};
+
+export const useConsoleTimerSettings = (): ConsoleTimerSettingsState => {
+  const [saved, setSaved] = useState<TimerSettings>(readTimerSettings);
+  const [isOpen, setIsOpen] = useState(false);
+  const [draft, setDraft] = useState<TimerSettings>(saved);
+
+  const openSettings = useCallback(() => {
+    setSaved((currentSaved) => {
+      setDraft(currentSaved);
+      return currentSaved;
+    });
+    setIsOpen(true);
+  }, []);
+
+  const closeSettings = useCallback(() => {
+    setIsOpen(false);
+  }, []);
+
+  const saveSettings = useCallback(() => {
+    setDraft((currentDraft) => {
+      writeTimerSettings(currentDraft);
+      setSaved(currentDraft);
+      return currentDraft;
+    });
+    setIsOpen(false);
+  }, []);
+
+  const toggleDraftTimerMode = useCallback((enabled: boolean) => {
+    setDraft((prev) => ({ ...prev, timerMode: enabled }));
+  }, []);
+
+  const changeDraftMinutes = useCallback((pjcode: string, minutes: number) => {
+    setDraft((prev) => ({
+      ...prev,
+      projectMinutes: { ...prev.projectMinutes, [pjcode]: minutes },
+    }));
+  }, []);
+
+  return {
+    timerMode: saved.timerMode,
+    projectMinutes: saved.projectMinutes,
+    isOpen,
+    draftTimerMode: draft.timerMode,
+    draftProjectMinutes: draft.projectMinutes,
+    openSettings,
+    closeSettings,
+    saveSettings,
+    toggleDraftTimerMode,
+    changeDraftMinutes,
+  };
+};

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.ts

@@ -438,3 +438,25 @@ export const postConsoleReorderStory = async (
     throw new Error(await readOperationErrorReason(response));
   }
 };
+
+export const fetchProjectList = async (): Promise<string[]> => {
+  const response = await fetch('/api/projects');
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  const payload: unknown = await response.json();
+  if (
+    payload === null ||
+    typeof payload !== 'object' ||
+    Array.isArray(payload)
+  ) {
+    return [];
+  }
+  const record = payload as Record<string, unknown>;
+  if (!Array.isArray(record.pjcodes)) {
+    return [];
+  }
+  return record.pjcodes.filter(
+    (entry): entry is string => typeof entry === 'string',
+  );
+};

package/src/adapter/entry-points/console/ui/src/features/console/lib/navigation.ts

@@ -0,0 +1,7 @@
+export const navigateReplace = (url: string): void => {
+  window.location.replace(url);
+};
+
+export const navigateAssign = (url: string): void => {
+  window.location.assign(url);
+};

package/src/adapter/entry-points/console/ui/src/features/console/logic/timerSettings.test.ts

@@ -0,0 +1,61 @@
+import { findNextPjcodeWithMinutes } from './timerSettings';
+
+describe('findNextPjcodeWithMinutes', () => {
+  const pjcodes = ['alpha', 'beta', 'gamma'];
+
+  it('returns the next pjcode after the current one with minutes > 0', () => {
+    const minutes = { alpha: 5, beta: 5, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBe('beta');
+    expect(findNextPjcodeWithMinutes(pjcodes, 'beta', minutes)).toBe('gamma');
+  });
+
+  it('wraps around to the first pjcode after the last one', () => {
+    const minutes = { alpha: 5, beta: 5, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'gamma', minutes)).toBe('alpha');
+  });
+
+  it('returns null when all projects have zero minutes', () => {
+    const minutes = { alpha: 0, beta: 0, gamma: 0 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBeNull();
+    expect(findNextPjcodeWithMinutes(pjcodes, null, minutes)).toBeNull();
+  });
+
+  it('skips projects with zero minutes', () => {
+    const minutes = { alpha: 5, beta: 0, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBe('gamma');
+  });
+
+  it('skips consecutive zero-minute projects and wraps around', () => {
+    const minutes = { alpha: 5, beta: 0, gamma: 0 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', minutes)).toBeNull();
+
+    const minutes2 = { alpha: 0, beta: 5, gamma: 0 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'gamma', minutes2)).toBe('beta');
+  });
+
+  it('returns the first pjcode with minutes > 0 when currentPjcode is null', () => {
+    const minutes = { alpha: 0, beta: 5, gamma: 3 };
+    expect(findNextPjcodeWithMinutes(pjcodes, null, minutes)).toBe('beta');
+  });
+
+  it('returns the first pjcode when currentPjcode is null and first has minutes > 0', () => {
+    const minutes = { alpha: 10, beta: 5, gamma: 3 };
+    expect(findNextPjcodeWithMinutes(pjcodes, null, minutes)).toBe('alpha');
+  });
+
+  it('treats missing projectMinutes entry as zero', () => {
+    expect(findNextPjcodeWithMinutes(pjcodes, 'alpha', {})).toBeNull();
+  });
+
+  it('returns null for an empty pjcodes list', () => {
+    expect(findNextPjcodeWithMinutes([], null, {})).toBeNull();
+    expect(findNextPjcodeWithMinutes([], 'alpha', {})).toBeNull();
+  });
+
+  it('handles currentPjcode not found in the list like null-origin', () => {
+    const minutes = { alpha: 5, beta: 5, gamma: 5 };
+    expect(findNextPjcodeWithMinutes(pjcodes, 'unknown', minutes)).toBe(
+      'alpha',
+    );
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/logic/timerSettings.ts

@@ -0,0 +1,77 @@
+export type TimerSettings = {
+  timerMode: boolean;
+  projectMinutes: Record<string, number>;
+};
+
+export const TIMER_SETTINGS_KEY = 'tdpm-timer-settings';
+
+const defaultSettings = (): TimerSettings => ({
+  timerMode: false,
+  projectMinutes: {},
+});
+
+export const readTimerSettings = (): TimerSettings => {
+  if (typeof localStorage === 'undefined') {
+    return defaultSettings();
+  }
+  const raw = localStorage.getItem(TIMER_SETTINGS_KEY);
+  if (raw === null) {
+    return defaultSettings();
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (
+      parsed === null ||
+      typeof parsed !== 'object' ||
+      Array.isArray(parsed)
+    ) {
+      return defaultSettings();
+    }
+    const record = parsed as Record<string, unknown>;
+    const timerMode =
+      typeof record.timerMode === 'boolean' ? record.timerMode : false;
+    const projectMinutesRaw = record.projectMinutes;
+    const projectMinutes: Record<string, number> =
+      projectMinutesRaw !== null &&
+      typeof projectMinutesRaw === 'object' &&
+      !Array.isArray(projectMinutesRaw)
+        ? Object.fromEntries(
+            Object.entries(projectMinutesRaw as Record<string, unknown>)
+              .filter(([, v]) => typeof v === 'number')
+              .map(([k, v]) => [k, v as number]),
+          )
+        : {};
+    return { timerMode, projectMinutes };
+  } catch {
+    return defaultSettings();
+  }
+};
+
+export const writeTimerSettings = (settings: TimerSettings): void => {
+  if (typeof localStorage !== 'undefined') {
+    localStorage.setItem(TIMER_SETTINGS_KEY, JSON.stringify(settings));
+  }
+};
+
+export const findNextPjcodeWithMinutes = (
+  pjcodes: string[],
+  currentPjcode: string | null,
+  projectMinutes: Record<string, number>,
+): string | null => {
+  if (pjcodes.length === 0) {
+    return null;
+  }
+  const currentIndex =
+    currentPjcode !== null ? pjcodes.indexOf(currentPjcode) : -1;
+  const startIndex =
+    currentIndex === -1 ? 0 : (currentIndex + 1) % pjcodes.length;
+  const count = currentIndex === -1 ? pjcodes.length : pjcodes.length - 1;
+  for (let i = 0; i < count; i++) {
+    const index = (startIndex + i) % pjcodes.length;
+    const pjcode = pjcodes[index];
+    if ((projectMinutes[pjcode] ?? 0) > 0) {
+      return pjcode;
+    }
+  }
+  return null;
+};