github-issue-tower-defence-management 2.19.1 → 2.19.3

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

@@ -1,277 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { postConsoleOperation } from '../lib/consoleApi';
-import {
-  ACTION_TOAST_DELAY_MS,
-  type ConsoleToastColor,
-} from '../logic/actionToast';
-
-export type ConsoleOfflinePayload = {
-  itemUrl: string;
-  projectItemId: string;
-  itemNumber: number;
-  repo: string;
-  isPr: boolean;
-  apiPath: string;
-  requestBody: Record<string, unknown>;
-};
-
-export type ConsoleOfflineQueuedAction = {
-  id: string;
-  message: string;
-  color: ConsoleToastColor;
-  enqueuedAt: number;
-} & ConsoleOfflinePayload;
-
-export type ConsoleQueuedAction = {
-  message: string;
-  color: ConsoleToastColor;
-  commit: () => Promise<void>;
-  advance: () => void;
-  offline?: ConsoleOfflinePayload;
-};
-
-export type ConsolePendingActionView = {
-  message: string;
-  color: ConsoleToastColor;
-  remainingSeconds: number;
-  progress: number;
-};
-
-export type ConsoleActionError = {
-  message: string;
-  reason: string;
-};
-
-const OFFLINE_QUEUE_STORAGE_KEY = 'console-offline-action-queue';
-
-const isConsoleOfflineQueuedAction = (
-  item: unknown,
-): item is ConsoleOfflineQueuedAction => {
-  if (typeof item !== 'object' || item === null) return false;
-  const a = item as Record<string, unknown>;
-  return (
-    typeof a.id === 'string' &&
-    typeof a.message === 'string' &&
-    typeof a.color === 'string' &&
-    typeof a.enqueuedAt === 'number' &&
-    typeof a.itemUrl === 'string' &&
-    typeof a.projectItemId === 'string' &&
-    typeof a.itemNumber === 'number' &&
-    typeof a.repo === 'string' &&
-    typeof a.isPr === 'boolean' &&
-    typeof a.apiPath === 'string' &&
-    typeof a.requestBody === 'object' &&
-    a.requestBody !== null
-  );
-};
-
-const loadOfflineQueue = (): ConsoleOfflineQueuedAction[] => {
-  try {
-    const raw = localStorage.getItem(OFFLINE_QUEUE_STORAGE_KEY);
-    if (raw === null) return [];
-    const parsed: unknown = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(isConsoleOfflineQueuedAction);
-  } catch {
-    return [];
-  }
-};
-
-const saveOfflineQueue = (actions: ConsoleOfflineQueuedAction[]): void => {
-  localStorage.setItem(OFFLINE_QUEUE_STORAGE_KEY, JSON.stringify(actions));
-};
-
-const generateId = (): string => {
-  if (
-    typeof crypto !== 'undefined' &&
-    typeof crypto.randomUUID === 'function'
-  ) {
-    return crypto.randomUUID();
-  }
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
-};
-
-const isNetworkError = (error: unknown): boolean => error instanceof TypeError;
-
-const errorReason = (error: unknown): string => {
-  if (error instanceof Error && error.message.length > 0) {
-    return error.message;
-  }
-  return String(error);
-};
-
-const COUNTDOWN_TICK_MS = 100;
-
-const computeRemainingSeconds = (elapsedMs: number): number =>
-  Math.max(0, Math.ceil((ACTION_TOAST_DELAY_MS - elapsedMs) / 1000));
-
-const computeProgress = (elapsedMs: number): number =>
-  Math.max(0, 1 - elapsedMs / ACTION_TOAST_DELAY_MS);
-
-export type ConsoleActionQueue = {
-  pending: ConsolePendingActionView | null;
-  error: ConsoleActionError | null;
-  offlineActions: ConsoleOfflineQueuedAction[];
-  enqueue: (action: ConsoleQueuedAction) => void;
-  showError: (message: string, reason: string) => void;
-  undo: () => void;
-  dismissError: () => void;
-  confirmOfflineAction: (id: string) => Promise<void>;
-  discardOfflineAction: (id: string) => void;
-};
-
-export const useConsoleActionQueue = (): ConsoleActionQueue => {
-  const [pending, setPending] = useState<ConsolePendingActionView | null>(null);
-  const [error, setError] = useState<ConsoleActionError | null>(null);
-  const [offlineActions, setOfflineActions] =
-    useState<ConsoleOfflineQueuedAction[]>(loadOfflineQueue);
-  const offlineActionsRef =
-    useRef<ConsoleOfflineQueuedAction[]>(offlineActions);
-  offlineActionsRef.current = offlineActions;
-
-  const actionRef = useRef<ConsoleQueuedAction | null>(null);
-  const startRef = useRef<number>(0);
-  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
-  const committedRef = useRef<boolean>(false);
-
-  const clearTimer = useCallback((): void => {
-    if (timerRef.current !== null) {
-      clearInterval(timerRef.current);
-      timerRef.current = null;
-    }
-  }, []);
-
-  const addToOfflineQueue = useCallback((action: ConsoleQueuedAction): void => {
-    if (action.offline === undefined) return;
-    const offlineAction: ConsoleOfflineQueuedAction = {
-      id: generateId(),
-      message: action.message,
-      color: action.color,
-      enqueuedAt: Date.now(),
-      ...action.offline,
-    };
-    setOfflineActions((prev) => {
-      const next = [...prev, offlineAction];
-      saveOfflineQueue(next);
-      return next;
-    });
-  }, []);
-
-  const runCommit = useCallback(
-    (action: ConsoleQueuedAction): void => {
-      action.commit().catch((cause: unknown) => {
-        if (isNetworkError(cause) && action.offline !== undefined) {
-          addToOfflineQueue(action);
-        } else {
-          setError({ message: action.message, reason: errorReason(cause) });
-        }
-      });
-    },
-    [addToOfflineQueue],
-  );
-
-  const commitPending = useCallback((): void => {
-    const action = actionRef.current;
-    clearTimer();
-    actionRef.current = null;
-    setPending(null);
-    if (action !== null && !committedRef.current) {
-      committedRef.current = true;
-      runCommit(action);
-    }
-  }, [clearTimer, runCommit]);
-
-  const undo = useCallback((): void => {
-    clearTimer();
-    actionRef.current = null;
-    committedRef.current = true;
-    setPending(null);
-  }, [clearTimer]);
-
-  const dismissError = useCallback((): void => {
-    setError(null);
-  }, []);
-
-  const showError = useCallback((message: string, reason: string): void => {
-    setError({ message, reason });
-  }, []);
-
-  const discardOfflineAction = useCallback((id: string): void => {
-    setOfflineActions((prev) => {
-      const next = prev.filter((a) => a.id !== id);
-      saveOfflineQueue(next);
-      return next;
-    });
-  }, []);
-
-  const confirmOfflineAction = useCallback(
-    async (id: string): Promise<void> => {
-      const action = offlineActionsRef.current.find((a) => a.id === id);
-      if (action === undefined) return;
-      try {
-        await postConsoleOperation(action.apiPath, action.requestBody);
-        discardOfflineAction(id);
-      } catch (cause: unknown) {
-        if (isNetworkError(cause)) {
-          setError({
-            message: action.message,
-            reason: 'Still offline — action is still held in the queue',
-          });
-        } else {
-          setError({ message: action.message, reason: errorReason(cause) });
-          discardOfflineAction(id);
-        }
-      }
-    },
-    [discardOfflineAction],
-  );
-
-  const enqueue = useCallback(
-    (action: ConsoleQueuedAction): void => {
-      if (actionRef.current !== null && !committedRef.current) {
-        const previous = actionRef.current;
-        clearTimer();
-        committedRef.current = true;
-        runCommit(previous);
-      }
-      committedRef.current = false;
-      actionRef.current = action;
-      startRef.current = Date.now();
-      setPending({
-        message: action.message,
-        color: action.color,
-        remainingSeconds: computeRemainingSeconds(0),
-        progress: computeProgress(0),
-      });
-      action.advance();
-      timerRef.current = setInterval(() => {
-        const elapsed = Date.now() - startRef.current;
-        if (elapsed >= ACTION_TOAST_DELAY_MS) {
-          commitPending();
-          return;
-        }
-        setPending({
-          message: action.message,
-          color: action.color,
-          remainingSeconds: computeRemainingSeconds(elapsed),
-          progress: computeProgress(elapsed),
-        });
-      }, COUNTDOWN_TICK_MS);
-    },
-    [clearTimer, commitPending, runCommit],
-  );
-
-  useEffect(() => clearTimer, [clearTimer]);
-
-  return {
-    pending,
-    error,
-    offlineActions,
-    enqueue,
-    showError,
-    undo,
-    dismissError,
-    confirmOfflineAction,
-    discardOfflineAction,
-  };
-};

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

@@ -1,99 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import type { AirplaneSnapshot } from '../lib/airplaneSnapshot';
-import { useConsoleCaches } from './useConsoleCaches';
-
-describe('useConsoleCaches', () => {
-  beforeEach(() => {
-    localStorage.clear();
-    window.history.replaceState({}, '', '/?k=token');
-  });
-
-  it('exposes one cache per resource and a stable identity across renders', () => {
-    const { result, rerender } = renderHook(() => useConsoleCaches());
-    const first = result.current;
-    expect(first.body).toBeDefined();
-    expect(first.comments).toBeDefined();
-    expect(first.files).toBeDefined();
-    expect(first.commits).toBeDefined();
-    expect(first.relatedPrs).toBeDefined();
-    expect(first.state).toBeDefined();
-    rerender();
-    expect(result.current).toBe(first);
-  });
-
-  it('pre-seeds item detail caches from airplane snapshot so item detail renders with network rejecting', () => {
-    const prUrl = 'https://github.com/owner/repo/pull/42';
-    const airplaneSnapshot: AirplaneSnapshot = {
-      capturedAt: '2026-08-01T10:00:00Z',
-      failures: [],
-      tabs: {},
-      items: {
-        [prUrl]: {
-          body: 'PR body text',
-          comments: [
-            {
-              author: 'alice',
-              body: 'LGTM',
-              createdAt: '2026-08-01T09:00:00Z',
-            },
-          ],
-          state: {
-            state: 'open',
-            merged: false,
-            isPullRequest: true,
-            title: 'Offline PR',
-          },
-          files: [
-            {
-              path: 'src/foo.ts',
-              additions: 3,
-              deletions: 1,
-              status: 'modified',
-              patch: '@@ -1 +1 @@\n-old\n+new',
-              rawUrl: null,
-            },
-          ],
-          commits: [
-            {
-              sha: 'abc123',
-              message: 'fix: something',
-              author: 'alice',
-              authoredAt: '2026-08-01T08:00:00Z',
-            },
-          ],
-          prStatus: {
-            found: true,
-            isConflicted: false,
-            mergeableStatus: 'MERGEABLE',
-            isPassedAllCiJob: true,
-            isCiStateSuccess: true,
-            isBranchOutOfDate: false,
-            missingRequiredCheckNames: [],
-          },
-          relatedPrs: null,
-        },
-      },
-    };
-
-    const { result } = renderHook(() => useConsoleCaches(airplaneSnapshot));
-
-    const cacheKey = 'owner/repo#42';
-    expect(result.current.body.peek(cacheKey)).toBe('PR body text');
-
-    const comments = result.current.comments.peek(cacheKey);
-    expect(comments).toHaveLength(1);
-    expect(comments?.[0].author).toBe('alice');
-
-    const files = result.current.files.peek(cacheKey);
-    expect(files).toHaveLength(1);
-    expect(files?.[0].path).toBe('src/foo.ts');
-
-    const commits = result.current.commits.peek(cacheKey);
-    expect(commits).toHaveLength(1);
-    expect(commits?.[0].sha).toBe('abc123');
-
-    const prStatus = result.current.prStatus.peek(cacheKey);
-    expect(prStatus?.isPassedAllCiJob).toBe(true);
-    expect(prStatus?.mergeableStatus).toBe('MERGEABLE');
-  });
-});

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

@@ -1,90 +0,0 @@
-import { useMemo } from 'react';
-import type { AirplaneSnapshot } from '../lib/airplaneSnapshot';
-import {
-  type ConsoleApiClient,
-  createConsoleApiClient,
-} from '../lib/consoleApi';
-import { ResourceCache } from '../lib/resourceCache';
-import type {
-  ConsoleChangedFile,
-  ConsoleComment,
-  ConsoleCommit,
-  ConsoleIssueState,
-  ConsolePullRequestStatus,
-  ConsoleRelatedPullRequest,
-} from '../logic/types';
-
-export type ConsoleCaches = {
-  body: ResourceCache<string>;
-  comments: ResourceCache<ConsoleComment[]>;
-  files: ResourceCache<ConsoleChangedFile[]>;
-  commits: ResourceCache<ConsoleCommit[]>;
-  relatedPrs: ResourceCache<ConsoleRelatedPullRequest[]>;
-  state: ResourceCache<ConsoleIssueState>;
-  prStatus: ResourceCache<ConsolePullRequestStatus>;
-  client: ConsoleApiClient;
-};
-
-const deriveCacheKey = (url: string): string => {
-  try {
-    const urlObj = new URL(url);
-    const parts = urlObj.pathname.split('/').filter(Boolean);
-    if (parts.length >= 4) {
-      const owner = parts[0];
-      const repoName = parts[1];
-      const number = parts[3];
-      return `${owner}/${repoName}#${number}`;
-    }
-  } catch {}
-  return url;
-};
-
-const populateCachesFromSnapshot = (
-  caches: ConsoleCaches,
-  snapshot: AirplaneSnapshot,
-): void => {
-  for (const [url, item] of Object.entries(snapshot.items)) {
-    const key = deriveCacheKey(url);
-    caches.body.seed(key, item.body);
-    caches.comments.seed(key, item.comments);
-    caches.state.seed(key, item.state);
-    if (item.files !== null) {
-      caches.files.seed(key, item.files);
-    }
-    if (item.commits !== null) {
-      caches.commits.seed(key, item.commits);
-    }
-    if (item.prStatus !== null) {
-      caches.prStatus.seed(key, item.prStatus);
-    }
-    if (item.relatedPrs !== null) {
-      caches.relatedPrs.seed(key, item.relatedPrs);
-    }
-  }
-};
-
-export const useConsoleCaches = (
-  airplaneSnapshot: AirplaneSnapshot | null = null,
-): ConsoleCaches => {
-  return useMemo(() => {
-    const client = createConsoleApiClient();
-    const caches: ConsoleCaches = {
-      client,
-      body: new ResourceCache<string>(client.fetchItemBody),
-      comments: new ResourceCache<ConsoleComment[]>(client.fetchComments),
-      files: new ResourceCache<ConsoleChangedFile[]>(client.fetchPrFiles),
-      commits: new ResourceCache<ConsoleCommit[]>(client.fetchPrCommits),
-      relatedPrs: new ResourceCache<ConsoleRelatedPullRequest[]>(
-        client.fetchRelatedPrs,
-      ),
-      state: new ResourceCache<ConsoleIssueState>(client.fetchIssueState),
-      prStatus: new ResourceCache<ConsolePullRequestStatus>(
-        client.fetchPullRequestStatus,
-      ),
-    };
-    if (airplaneSnapshot !== null) {
-      populateCachesFromSnapshot(caches, airplaneSnapshot);
-    }
-    return caches;
-  }, [airplaneSnapshot]);
-};

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

@@ -1,110 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { ResourceCache } from '../lib/resourceCache';
-import type { ConsoleListItem } from '../logic/types';
-import type { ConsoleCaches } from './useConsoleCaches';
-import { useConsoleDetailPrefetch } from './useConsoleDetailPrefetch';
-
-const makeItem = (
-  number: number,
-  overrides: Partial<ConsoleListItem> = {},
-): ConsoleListItem => ({
-  number,
-  title: `Item ${number}`,
-  url: `https://github.com/o/r/issues/${number}`,
-  repo: 'o/r',
-  nameWithOwner: 'o/r',
-  projectItemId: `PVTI_${number}`,
-  itemId: `PVTI_${number}`,
-  isPr: false,
-  relatedOpenPullRequestUrls: [],
-  story: 'Story',
-  status: null,
-  agent: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  dependedIssueUrls: [],
-  labels: [],
-  createdAt: '2026-06-10T00:00:00.000Z',
-  ...overrides,
-});
-
-const buildCaches = (): ConsoleCaches => {
-  const never = () => new Promise<never>(() => {});
-  return {
-    client: {} as ConsoleCaches['client'],
-    body: new ResourceCache<string>(never),
-    comments: new ResourceCache(never),
-    files: new ResourceCache(never),
-    commits: new ResourceCache(never),
-    relatedPrs: new ResourceCache(never),
-    state: new ResourceCache(never),
-    prStatus: new ResourceCache(never),
-  };
-};
-
-describe('useConsoleDetailPrefetch', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    const idleWindow = window as unknown as Record<string, unknown>;
-    idleWindow.requestIdleCallback = undefined;
-    idleWindow.cancelIdleCallback = undefined;
-  });
-
-  afterEach(() => {
-    jest.runAllTimers();
-    jest.useRealTimers();
-  });
-
-  it('is disabled and schedules no prefetch for issue items', () => {
-    const caches = buildCaches();
-    const bodyPrefetch = jest.spyOn(caches.body, 'prefetch');
-    const statePrefetch = jest.spyOn(caches.state, 'prefetch');
-    const commentsPrefetch = jest.spyOn(caches.comments, 'prefetch');
-    const relatedPrefetch = jest.spyOn(caches.relatedPrs, 'prefetch');
-    const items = [makeItem(1), makeItem(2), makeItem(3)];
-    renderHook(() => useConsoleDetailPrefetch(caches, items[0], items));
-    jest.runAllTimers();
-
-    expect(bodyPrefetch).not.toHaveBeenCalled();
-    expect(statePrefetch).not.toHaveBeenCalled();
-    expect(commentsPrefetch).not.toHaveBeenCalled();
-    expect(relatedPrefetch).not.toHaveBeenCalled();
-  });
-
-  it('is disabled and schedules no prefetch for pull request items', () => {
-    const caches = buildCaches();
-    const filesPrefetch = jest.spyOn(caches.files, 'prefetch');
-    const commitsPrefetch = jest.spyOn(caches.commits, 'prefetch');
-    const prStatusPrefetch = jest.spyOn(caches.prStatus, 'prefetch');
-    const items = [
-      makeItem(1),
-      makeItem(2, { isPr: true, url: 'https://github.com/o/r/pull/2' }),
-    ];
-    renderHook(() => useConsoleDetailPrefetch(caches, items[0], items));
-    jest.runAllTimers();
-
-    expect(filesPrefetch).not.toHaveBeenCalled();
-    expect(commitsPrefetch).not.toHaveBeenCalled();
-    expect(prStatusPrefetch).not.toHaveBeenCalled();
-  });
-
-  it('does nothing when no item is selected', () => {
-    const caches = buildCaches();
-    const bodyPrefetch = jest.spyOn(caches.body, 'prefetch');
-    const items = [makeItem(1), makeItem(2)];
-    renderHook(() => useConsoleDetailPrefetch(caches, null, items));
-    jest.runAllTimers();
-
-    expect(bodyPrefetch).not.toHaveBeenCalled();
-  });
-
-  it('does not prefetch when the selected item is the last in the list', () => {
-    const caches = buildCaches();
-    const bodyPrefetch = jest.spyOn(caches.body, 'prefetch');
-    const items = [makeItem(1), makeItem(2)];
-    renderHook(() => useConsoleDetailPrefetch(caches, items[1], items));
-    jest.runAllTimers();
-
-    expect(bodyPrefetch).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,83 +0,0 @@
-import { useEffect } from 'react';
-import type { ConsoleListItem } from '../logic/types';
-import type { ConsoleCaches } from './useConsoleCaches';
-
-const PREFETCH_AHEAD_COUNT = 0;
-const PREFETCH_DEFER_MS = 500;
-const PREFETCH_IDLE_TIMEOUT_MS = 2000;
-
-type IdleHandle = { cancel: () => void };
-
-const scheduleOnIdle = (task: () => void): IdleHandle => {
-  const idleWindow = window as Window & {
-    requestIdleCallback?: (
-      callback: () => void,
-      options?: { timeout: number },
-    ) => number;
-    cancelIdleCallback?: (handle: number) => void;
-  };
-  if (
-    typeof idleWindow.requestIdleCallback === 'function' &&
-    typeof idleWindow.cancelIdleCallback === 'function'
-  ) {
-    const handle = idleWindow.requestIdleCallback(task, {
-      timeout: PREFETCH_IDLE_TIMEOUT_MS,
-    });
-    return { cancel: () => idleWindow.cancelIdleCallback?.(handle) };
-  }
-  const handle = window.setTimeout(task, 0);
-  return { cancel: () => window.clearTimeout(handle) };
-};
-
-const prefetchItem = (caches: ConsoleCaches, item: ConsoleListItem): void => {
-  const key = `${item.repo}#${item.number}`;
-  caches.body.prefetch(key, item.url);
-  caches.state.prefetch(key, item.url);
-  caches.comments.prefetch(key, item.url);
-  if (item.isPr) {
-    caches.files.prefetch(key, item.url);
-    caches.commits.prefetch(key, item.url);
-    caches.prStatus.prefetch(key, item.url);
-  } else {
-    caches.relatedPrs.prefetch(key, item.url);
-  }
-};
-
-export const useConsoleDetailPrefetch = (
-  caches: ConsoleCaches,
-  selectedItem: ConsoleListItem | null,
-  orderedPendingItems: ConsoleListItem[],
-): void => {
-  useEffect(() => {
-    if (selectedItem === null) {
-      return;
-    }
-    const selectedIndex = orderedPendingItems.findIndex(
-      (item) => item.projectItemId === selectedItem.projectItemId,
-    );
-    if (selectedIndex === -1) {
-      return;
-    }
-    const upcoming = orderedPendingItems.slice(
-      selectedIndex + 1,
-      selectedIndex + 1 + PREFETCH_AHEAD_COUNT,
-    );
-    if (upcoming.length === 0) {
-      return;
-    }
-
-    let idleHandle: IdleHandle | null = null;
-    const deferHandle = window.setTimeout(() => {
-      idleHandle = scheduleOnIdle(() => {
-        for (const item of upcoming) {
-          prefetchItem(caches, item);
-        }
-      });
-    }, PREFETCH_DEFER_MS);
-
-    return () => {
-      window.clearTimeout(deferHandle);
-      idleHandle?.cancel();
-    };
-  }, [caches, selectedItem, orderedPendingItems]);
-};