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

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

@@ -1,104 +0,0 @@
-import { ResourceCache, runWithConcurrency } from './resourceCache';
-
-describe('ResourceCache', () => {
-  it('fetches once and caches the result', async () => {
-    const fetcher = jest.fn(async (url: string) => `value:${url}`);
-    const cache = new ResourceCache(fetcher);
-    expect(await cache.load('k', 'u')).toBe('value:u');
-    expect(await cache.load('k', 'u')).toBe('value:u');
-    expect(fetcher).toHaveBeenCalledTimes(1);
-    expect(cache.peek('k')).toBe('value:u');
-  });
-
-  it('de-duplicates concurrent in-flight requests', async () => {
-    let resolveFetch: (value: string) => void = () => {};
-    const fetcher = jest.fn(
-      () =>
-        new Promise<string>((resolve) => {
-          resolveFetch = resolve;
-        }),
-    );
-    const cache = new ResourceCache(fetcher);
-    const first = cache.load('k', 'u');
-    const second = cache.load('k', 'u');
-    resolveFetch('shared');
-    expect(await first).toBe('shared');
-    expect(await second).toBe('shared');
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  it('allows a retry after a failed fetch', async () => {
-    const fetcher = jest
-      .fn<Promise<string>, [string]>()
-      .mockRejectedValueOnce(new Error('boom'))
-      .mockResolvedValueOnce('ok');
-    const cache = new ResourceCache(fetcher);
-    await expect(cache.load('k', 'u')).rejects.toThrow('boom');
-    expect(await cache.load('k', 'u')).toBe('ok');
-    expect(fetcher).toHaveBeenCalledTimes(2);
-  });
-
-  it('prefetches into the cache and serves the next load from it', async () => {
-    const fetcher = jest.fn(async (url: string) => `value:${url}`);
-    const cache = new ResourceCache(fetcher);
-    cache.prefetch('k', 'u');
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(cache.peek('k')).toBe('value:u');
-    expect(await cache.load('k', 'u')).toBe('value:u');
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not prefetch a key that is already cached', async () => {
-    const fetcher = jest.fn(async (url: string) => `value:${url}`);
-    const cache = new ResourceCache(fetcher);
-    await cache.load('k', 'u');
-    cache.prefetch('k', 'u');
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not start a second prefetch while one is in flight', async () => {
-    const fetcher = jest.fn(() => new Promise<string>(() => {}));
-    const cache = new ResourceCache(fetcher);
-    cache.prefetch('k', 'u');
-    cache.prefetch('k', 'u');
-    expect(fetcher).toHaveBeenCalledTimes(1);
-  });
-
-  it('swallows prefetch errors and leaves the key uncached', async () => {
-    const fetcher = jest
-      .fn<Promise<string>, [string]>()
-      .mockRejectedValue(new Error('boom'));
-    const cache = new ResourceCache(fetcher);
-    cache.prefetch('k', 'u');
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(cache.peek('k')).toBeUndefined();
-  });
-
-  it('invalidate removes a cached value so the next load refetches', async () => {
-    const fetcher = jest.fn(async (url: string) => `value:${url}`);
-    const cache = new ResourceCache(fetcher);
-    await cache.load('k', 'u');
-    cache.invalidate('k');
-    expect(cache.peek('k')).toBeUndefined();
-    await cache.load('k', 'u');
-    expect(fetcher).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe('runWithConcurrency', () => {
-  it('never exceeds the concurrency limit', async () => {
-    let active = 0;
-    let maxActive = 0;
-    const makeTask = () => async () => {
-      active += 1;
-      maxActive = Math.max(maxActive, active);
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      active -= 1;
-    };
-    const tasks = Array.from({ length: 6 }, makeTask);
-    await runWithConcurrency(tasks, 2);
-    expect(maxActive).toBeLessThanOrEqual(2);
-  });
-});

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

@@ -1,79 +0,0 @@
-export type ResourceFetcher<T> = (url: string) => Promise<T>;
-
-export class ResourceCache<T> {
-  private readonly cache = new Map<string, T>();
-  private readonly inFlight = new Map<string, Promise<T>>();
-  private readonly prefetchInFlight = new Set<string>();
-
-  constructor(private readonly fetcher: ResourceFetcher<T>) {}
-
-  peek = (key: string): T | undefined => this.cache.get(key);
-
-  has = (key: string): boolean => this.cache.has(key);
-
-  load = (key: string, url: string): Promise<T> => {
-    const cached = this.cache.get(key);
-    if (cached !== undefined) {
-      return Promise.resolve(cached);
-    }
-    const pending = this.inFlight.get(key);
-    if (pending !== undefined) {
-      return pending;
-    }
-    const promise = this.fetcher(url)
-      .then((value) => {
-        this.cache.set(key, value);
-        return value;
-      })
-      .finally(() => {
-        this.inFlight.delete(key);
-      });
-    this.inFlight.set(key, promise);
-    return promise;
-  };
-
-  prefetch = (key: string, url: string): void => {
-    if (
-      this.cache.has(key) ||
-      this.inFlight.has(key) ||
-      this.prefetchInFlight.has(key)
-    ) {
-      return;
-    }
-    this.prefetchInFlight.add(key);
-    this.fetcher(url)
-      .then((value) => {
-        this.cache.set(key, value);
-      })
-      .catch(() => {})
-      .finally(() => {
-        this.prefetchInFlight.delete(key);
-      });
-  };
-
-  seed(key: string, value: T): void {
-    this.cache.set(key, value);
-  }
-
-  invalidate = (key: string): void => {
-    this.cache.delete(key);
-  };
-}
-
-export const runWithConcurrency = async (
-  tasks: (() => Promise<unknown>)[],
-  limit: number,
-): Promise<void> => {
-  let index = 0;
-  const workers = Array.from(
-    { length: Math.min(limit, tasks.length) },
-    async () => {
-      while (index < tasks.length) {
-        const current = tasks[index];
-        index += 1;
-        await current();
-      }
-    },
-  );
-  await Promise.all(workers);
-};

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

@@ -1,200 +0,0 @@
-import { consoleListItemsFixture } from '../testing/fixtures';
-import {
-  ACTION_TOAST_DELAY_MS,
-  actionAdvances,
-  actionToastColor,
-  actionToastMessage,
-  type ConsoleActionKind,
-  formatActionToast,
-  itemToastLabel,
-} from './actionToast';
-
-const prItem = consoleListItemsFixture[0];
-const issueItem = consoleListItemsFixture[2];
-
-describe('ACTION_TOAST_DELAY_MS', () => {
-  it('is the five second cancellable window', () => {
-    expect(ACTION_TOAST_DELAY_MS).toBe(5000);
-  });
-});
-
-describe('itemToastLabel', () => {
-  it('prefixes pull requests with PR #', () => {
-    expect(itemToastLabel(prItem)).toBe(`PR #${prItem.number}`);
-  });
-
-  it('prefixes issues with #', () => {
-    expect(itemToastLabel(issueItem)).toBe(`#${issueItem.number}`);
-  });
-});
-
-describe('actionToastMessage', () => {
-  it('labels review actions', () => {
-    expect(
-      actionToastMessage(
-        { type: 'review', action: 'approve_and_merge' },
-        'prs',
-      ),
-    ).toBe('Approved & Merged');
-    expect(
-      actionToastMessage({ type: 'review', action: 'request_changes' }, 'prs'),
-    ).toBe('Rejected');
-    expect(
-      actionToastMessage({ type: 'review', action: 'totally_wrong' }, 'prs'),
-    ).toBe('Marked totally wrong');
-    expect(
-      actionToastMessage({ type: 'review', action: 'unnecessary' }, 'prs'),
-    ).toBe('Marked unnecessary');
-  });
-
-  it('labels the +1 week snooze differently on the manual triage tabs', () => {
-    const kind: ConsoleActionKind = {
-      type: 'next_action_date',
-      action: 'snooze_1week',
-    };
-    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Date +1 week');
-    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
-      'Next Action Date +1 week and skip',
-    );
-    expect(actionToastMessage(kind, 'todo-by-agent')).toBe(
-      'Next Action Date +1 week and skip',
-    );
-  });
-
-  it('labels the +1 day snooze the same on every tab', () => {
-    const kind: ConsoleActionKind = {
-      type: 'next_action_date',
-      action: 'snooze_1day',
-    };
-    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Date +1 day');
-    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
-      'Next Action Date +1 day',
-    );
-  });
-
-  it('labels the +1 hour snooze the same on every tab', () => {
-    const kind: ConsoleActionKind = {
-      type: 'next_action_date',
-      action: 'snooze_1hour',
-    };
-    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Hour +1 hour');
-    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
-      'Next Action Hour +1 hour',
-    );
-  });
-
-  it('labels the +3 hours snooze the same on every tab', () => {
-    const kind: ConsoleActionKind = {
-      type: 'next_action_date',
-      action: 'snooze_3hours',
-    };
-    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Hour +3 hours');
-    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
-      'Next Action Hour +3 hours',
-    );
-  });
-
-  it('labels close actions', () => {
-    expect(actionToastMessage({ type: 'close', action: 'close' }, 'prs')).toBe(
-      'Closed',
-    );
-    expect(
-      actionToastMessage({ type: 'close', action: 'close_not_planned' }, 'prs'),
-    ).toBe('Closed as not planned');
-  });
-
-  it('labels the in-tmux-by-human action', () => {
-    expect(
-      actionToastMessage(
-        { type: 'set_in_tmux_by_human', optionName: 'In Tmux by human' },
-        'prs',
-      ),
-    ).toBe('Added to In Tmux by human');
-  });
-
-  it('labels field updates with the chosen option name', () => {
-    expect(
-      actionToastMessage(
-        { type: 'set_status', optionName: 'Awaiting Workspace' },
-        'prs',
-      ),
-    ).toBe('Status → Awaiting Workspace');
-    expect(
-      actionToastMessage(
-        { type: 'set_story', optionName: 'Move to Okinawa' },
-        'todo-by-human',
-      ),
-    ).toBe('Story → Move to Okinawa');
-  });
-});
-
-describe('actionToastColor', () => {
-  it('colors each action group like the reference', () => {
-    expect(
-      actionToastColor({ type: 'review', action: 'approve_and_merge' }),
-    ).toBe('green');
-    expect(
-      actionToastColor({ type: 'review', action: 'request_changes' }),
-    ).toBe('amber');
-    expect(actionToastColor({ type: 'review', action: 'totally_wrong' })).toBe(
-      'red',
-    );
-    expect(actionToastColor({ type: 'review', action: 'unnecessary' })).toBe(
-      'gray',
-    );
-    expect(
-      actionToastColor({ type: 'set_status', optionName: 'Todo by human' }),
-    ).toBe('blue');
-    expect(
-      actionToastColor({ type: 'next_action_date', action: 'snooze_1day' }),
-    ).toBe('amber');
-    expect(actionToastColor({ type: 'close', action: 'close' })).toBe('red');
-    expect(actionToastColor({ type: 'ok_and_awaiting_workspace' })).toBe(
-      'blue',
-    );
-  });
-});
-
-describe('actionToastMessage for ok_and_awaiting_workspace', () => {
-  it('returns the composite label', () => {
-    expect(
-      actionToastMessage({ type: 'ok_and_awaiting_workspace' }, 'prs'),
-    ).toBe('ok → Awaiting Workspace');
-  });
-});
-
-describe('actionAdvances', () => {
-  it('advances every non-snooze action in every tab', () => {
-    expect(
-      actionAdvances({ type: 'review', action: 'approve_and_merge' }, 'prs'),
-    ).toBe(true);
-    expect(actionAdvances({ type: 'set_status', optionName: 'x' }, 'prs')).toBe(
-      true,
-    );
-    expect(actionAdvances({ type: 'ok_and_awaiting_workspace' }, 'prs')).toBe(
-      true,
-    );
-  });
-
-  it('does not advance a snooze except on the manual triage tabs', () => {
-    const kind: ConsoleActionKind = {
-      type: 'next_action_date',
-      action: 'snooze_1week',
-    };
-    expect(actionAdvances(kind, 'prs')).toBe(false);
-    expect(actionAdvances(kind, 'todo-by-human')).toBe(true);
-    expect(actionAdvances(kind, 'todo-by-agent')).toBe(true);
-  });
-});
-
-describe('formatActionToast', () => {
-  it('combines the message and the item label', () => {
-    expect(
-      formatActionToast(
-        { type: 'review', action: 'approve_and_merge' },
-        prItem,
-        'prs',
-      ),
-    ).toBe(`Approved & Merged — PR #${prItem.number}`);
-  });
-});

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

@@ -1,122 +0,0 @@
-import {
-  type ConsoleCloseAction,
-  type ConsoleNextActionDateAction,
-  type ConsoleReviewAction,
-  isManualTriageTab,
-} from './operations';
-import type { ConsoleListItem, ConsoleTabName } from './types';
-
-export type ConsoleToastColor =
-  | 'green'
-  | 'amber'
-  | 'red'
-  | 'gray'
-  | 'blue'
-  | 'error';
-
-export type ConsoleActionKind =
-  | { type: 'review'; action: ConsoleReviewAction }
-  | { type: 'next_action_date'; action: ConsoleNextActionDateAction }
-  | { type: 'set_story'; optionName: string }
-  | { type: 'set_status'; optionName: string }
-  | { type: 'set_in_tmux_by_human'; optionName: string }
-  | { type: 'close'; action: ConsoleCloseAction }
-  | { type: 'ok_and_awaiting_workspace' }
-  | { type: 'delete_all_comments' };
-
-export const ACTION_TOAST_DELAY_MS = 5000;
-
-export const itemToastLabel = (item: ConsoleListItem): string =>
-  `${item.isPr ? 'PR #' : '#'}${item.number}`;
-
-export const actionToastMessage = (
-  kind: ConsoleActionKind,
-  tab: ConsoleTabName,
-): string => {
-  switch (kind.type) {
-    case 'review':
-      if (kind.action === 'approve_and_merge') {
-        return 'Approved & Merged';
-      }
-      if (kind.action === 'request_changes') {
-        return 'Rejected';
-      }
-      if (kind.action === 'totally_wrong') {
-        return 'Marked totally wrong';
-      }
-      return 'Marked unnecessary';
-    case 'next_action_date':
-      if (kind.action === 'snooze_1hour') {
-        return 'Next Action Hour +1 hour';
-      }
-      if (kind.action === 'snooze_3hours') {
-        return 'Next Action Hour +3 hours';
-      }
-      if (kind.action === 'snooze_1day') {
-        return 'Next Action Date +1 day';
-      }
-      return isManualTriageTab(tab)
-        ? 'Next Action Date +1 week and skip'
-        : 'Next Action Date +1 week';
-    case 'set_story':
-      return `Story → ${kind.optionName}`;
-    case 'set_status':
-      return `Status → ${kind.optionName}`;
-    case 'set_in_tmux_by_human':
-      return 'Added to In Tmux by human';
-    case 'ok_and_awaiting_workspace':
-      return 'ok → Awaiting Workspace';
-    case 'close':
-      return kind.action === 'close' ? 'Closed' : 'Closed as not planned';
-    case 'delete_all_comments':
-      return 'Deleted all comments';
-  }
-};
-
-export const actionToastColor = (
-  kind: ConsoleActionKind,
-): ConsoleToastColor => {
-  switch (kind.type) {
-    case 'review':
-      if (kind.action === 'approve_and_merge') {
-        return 'green';
-      }
-      if (kind.action === 'request_changes') {
-        return 'amber';
-      }
-      if (kind.action === 'totally_wrong') {
-        return 'red';
-      }
-      return 'gray';
-    case 'next_action_date':
-      return 'amber';
-    case 'set_story':
-    case 'set_status':
-    case 'set_in_tmux_by_human':
-    case 'ok_and_awaiting_workspace':
-      return 'blue';
-    case 'close':
-      return 'red';
-    case 'delete_all_comments':
-      return 'red';
-  }
-};
-
-export const actionAdvances = (
-  kind: ConsoleActionKind,
-  tab: ConsoleTabName,
-): boolean => {
-  if (kind.type === 'next_action_date') {
-    return isManualTriageTab(tab);
-  }
-  if (kind.type === 'delete_all_comments') {
-    return false;
-  }
-  return true;
-};
-
-export const formatActionToast = (
-  kind: ConsoleActionKind,
-  item: ConsoleListItem,
-  tab: ConsoleTabName,
-): string => `${actionToastMessage(kind, tab)} — ${itemToastLabel(item)}`;

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

@@ -1,90 +0,0 @@
-import { copyTextToClipboard } from './clipboard';
-
-describe('copyTextToClipboard', () => {
-  const originalClipboardDescriptor = Object.getOwnPropertyDescriptor(
-    window.navigator,
-    'clipboard',
-  );
-
-  const setClipboard = (clipboard: unknown): void => {
-    Object.defineProperty(window.navigator, 'clipboard', {
-      value: clipboard,
-      configurable: true,
-    });
-  };
-
-  afterEach(() => {
-    if (originalClipboardDescriptor === undefined) {
-      Reflect.deleteProperty(window.navigator, 'clipboard');
-    } else {
-      Object.defineProperty(
-        window.navigator,
-        'clipboard',
-        originalClipboardDescriptor,
-      );
-    }
-    jest.restoreAllMocks();
-  });
-
-  it('writes through the clipboard api when it is available', async () => {
-    const writeText = jest.fn().mockResolvedValue(undefined);
-    setClipboard({ writeText });
-
-    await copyTextToClipboard('copied value');
-
-    expect(writeText).toHaveBeenCalledWith('copied value');
-  });
-
-  it('copies through the document selection command when the clipboard api is absent', async () => {
-    setClipboard(undefined);
-    const execCommand = jest.fn().mockReturnValue(true);
-    Object.defineProperty(document, 'execCommand', {
-      value: execCommand,
-      configurable: true,
-    });
-
-    await copyTextToClipboard('value on a plain http origin');
-
-    expect(execCommand).toHaveBeenCalledWith('copy');
-  });
-
-  it('leaves no element behind after the document selection command', async () => {
-    setClipboard(undefined);
-    Object.defineProperty(document, 'execCommand', {
-      value: jest.fn().mockReturnValue(true),
-      configurable: true,
-    });
-    const childCountBefore = document.body.childElementCount;
-
-    await copyTextToClipboard('value on a plain http origin');
-
-    expect(document.body.childElementCount).toBe(childCountBefore);
-  });
-
-  it('falls through to the document selection command when the clipboard api rejects', async () => {
-    setClipboard({
-      writeText: jest.fn().mockRejectedValue(new Error('denied')),
-    });
-    const execCommand = jest.fn().mockReturnValue(true);
-    Object.defineProperty(document, 'execCommand', {
-      value: execCommand,
-      configurable: true,
-    });
-
-    await copyTextToClipboard('value');
-
-    expect(execCommand).toHaveBeenCalledWith('copy');
-  });
-
-  it('rejects when neither the clipboard api nor the document selection command copies', async () => {
-    setClipboard(undefined);
-    Object.defineProperty(document, 'execCommand', {
-      value: jest.fn().mockReturnValue(false),
-      configurable: true,
-    });
-
-    await expect(copyTextToClipboard('value')).rejects.toThrow(
-      'Copying to the clipboard is not available in this browser context.',
-    );
-  });
-});

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

@@ -1,37 +0,0 @@
-const CLIPBOARD_UNAVAILABLE_MESSAGE =
-  'Copying to the clipboard is not available in this browser context.';
-
-const copyThroughDocumentSelection = (value: string): boolean => {
-  const textArea = document.createElement('textarea');
-  textArea.value = value;
-  textArea.setAttribute('readonly', '');
-  textArea.style.position = 'fixed';
-  textArea.style.top = '0';
-  textArea.style.left = '0';
-  textArea.style.opacity = '0';
-  document.body.appendChild(textArea);
-  textArea.select();
-  textArea.setSelectionRange(0, value.length);
-  const copied = document.execCommand('copy');
-  textArea.remove();
-  return copied;
-};
-
-export const copyTextToClipboard = async (value: string): Promise<void> => {
-  const clipboard = navigator.clipboard;
-  if (clipboard !== undefined && typeof clipboard.writeText === 'function') {
-    try {
-      await clipboard.writeText(value);
-      return;
-    } catch {
-      if (copyThroughDocumentSelection(value)) {
-        return;
-      }
-      throw new Error(CLIPBOARD_UNAVAILABLE_MESSAGE);
-    }
-  }
-  if (copyThroughDocumentSelection(value)) {
-    return;
-  }
-  throw new Error(CLIPBOARD_UNAVAILABLE_MESSAGE);
-};

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

@@ -1,34 +0,0 @@
-import { CONSOLE_COLOR_PALETTE, colorFromEnum } from './colors';
-
-describe('colorFromEnum', () => {
-  it('returns the exact palette entry for a known enum', () => {
-    expect(colorFromEnum('GREEN')).toEqual({
-      dot: '#3fb950',
-      bg: 'rgba(46,160,67,0.15)',
-      fg: '#3fb950',
-      border: 'rgba(46,160,67,0.4)',
-    });
-  });
-
-  it('is case insensitive', () => {
-    expect(colorFromEnum('purple')).toBe(CONSOLE_COLOR_PALETTE.PURPLE);
-  });
-
-  it('falls back to GRAY for an unknown enum', () => {
-    expect(colorFromEnum('MAGENTA')).toBe(CONSOLE_COLOR_PALETTE.GRAY);
-  });
-
-  it('falls back to GRAY for null', () => {
-    expect(colorFromEnum(null)).toBe(CONSOLE_COLOR_PALETTE.GRAY);
-  });
-
-  it('uses the documented dot colors for every enum', () => {
-    expect(CONSOLE_COLOR_PALETTE.GRAY.dot).toBe('#848d97');
-    expect(CONSOLE_COLOR_PALETTE.BLUE.dot).toBe('#4493f8');
-    expect(CONSOLE_COLOR_PALETTE.YELLOW.dot).toBe('#d29922');
-    expect(CONSOLE_COLOR_PALETTE.ORANGE.dot).toBe('#db6d28');
-    expect(CONSOLE_COLOR_PALETTE.RED.dot).toBe('#f85149');
-    expect(CONSOLE_COLOR_PALETTE.PINK.dot).toBe('#db61a2');
-    expect(CONSOLE_COLOR_PALETTE.PURPLE.dot).toBe('#a371f7');
-  });
-});