github-issue-tower-defence-management 2.19.0 → 2.19.2

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

@@ -1,252 +0,0 @@
-import {
-  type ConsoleMarkdownSegment,
-  hasMermaidFence,
-  renderMarkdownToSafeHtml,
-  splitMarkdownSegments,
-} from './markdown';
-
-const stripKey = (segment: ConsoleMarkdownSegment): Record<string, unknown> => {
-  if (segment.kind === 'mermaid') {
-    return { kind: segment.kind, code: segment.code };
-  }
-  return { kind: segment.kind, source: segment.source };
-};
-
-describe('renderMarkdownToSafeHtml', () => {
-  it('renders headings and lists', () => {
-    const html = renderMarkdownToSafeHtml('# Title\n\n- one\n- two');
-    expect(html).toContain('<h1');
-    expect(html).toContain('<li>one</li>');
-  });
-
-  it('renders GitHub-flavored markdown tables', () => {
-    const html = renderMarkdownToSafeHtml(
-      '| Name | Value |\n| --- | --- |\n| one | 1 |',
-    );
-    expect(html).toContain('<table>');
-    expect(html).toContain('<th>Name</th>');
-    expect(html).toContain('<td>one</td>');
-  });
-
-  it('strips script tags via DOMPurify', () => {
-    const html = renderMarkdownToSafeHtml(
-      'before <script>alert(1)</script> after',
-    );
-    expect(html).not.toContain('<script>');
-    expect(html).not.toContain('alert(1)');
-  });
-
-  it('strips event-handler attributes', () => {
-    const html = renderMarkdownToSafeHtml('<img src="x" onerror="alert(1)">');
-    expect(html).not.toContain('onerror');
-  });
-
-  it('returns an empty string for blank input', () => {
-    expect(renderMarkdownToSafeHtml('   ')).toBe('');
-  });
-
-  it('renders GitHub emoji shortcodes as Unicode emoji glyphs', () => {
-    const html = renderMarkdownToSafeHtml(':magic_wand: :sparkles: :rocket:');
-    expect(html).toContain('🪄');
-    expect(html).toContain('✨');
-    expect(html).toContain('🚀');
-    expect(html).not.toContain(':magic_wand:');
-    expect(html).not.toContain(':sparkles:');
-    expect(html).not.toContain(':rocket:');
-  });
-
-  it('links a bare #N reference to the provided repo issues path', () => {
-    const html = renderMarkdownToSafeHtml('close #127', {
-      owner: 'HiromiShikata',
-      repo: 'npm-cli-github-issue-tower-defence-management',
-    });
-    expect(html).toContain(
-      '<a href="https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/issues/127" target="_blank" rel="noopener noreferrer">#127</a>',
-    );
-  });
-
-  it('keeps a bare #N reference as plain text when no repo context is given', () => {
-    const html = renderMarkdownToSafeHtml('close #127');
-    expect(html).toContain('#127');
-    expect(html).not.toContain('<a ');
-  });
-
-  it('keeps a full GitHub URL as a rendered link', () => {
-    const html = renderMarkdownToSafeHtml(
-      'see https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/issues/42',
-      {
-        owner: 'HiromiShikata',
-        repo: 'npm-cli-github-issue-tower-defence-management',
-      },
-    );
-    expect(html).toContain(
-      'href="https://github.com/HiromiShikata/npm-cli-github-issue-tower-defence-management/issues/42"',
-    );
-  });
-
-  it('preserves the href attribute on issue reference anchors after sanitization', () => {
-    const html = renderMarkdownToSafeHtml('resolves #9', {
-      owner: 'owner',
-      repo: 'repo',
-    });
-    expect(html).toContain('href="https://github.com/owner/repo/issues/9"');
-  });
-
-  it('links an owner/repo#N reference to the referenced repository issues path', () => {
-    const html = renderMarkdownToSafeHtml(
-      '- close other-owner/other-repo#1547',
-      {
-        owner: 'owner',
-        repo: 'repo',
-      },
-    );
-    expect(html).toContain(
-      'href="https://github.com/other-owner/other-repo/issues/1547"',
-    );
-    expect(html).toContain('>other-owner/other-repo#1547</a>');
-  });
-
-  it('does not link the number of an owner/repo#N reference to the displayed repository', () => {
-    const html = renderMarkdownToSafeHtml(
-      '- close other-owner/other-repo#1547',
-      {
-        owner: 'owner',
-        repo: 'repo',
-      },
-    );
-    expect(html).not.toContain('https://github.com/owner/repo/issues/1547');
-  });
-
-  it('links an owner/repo#N reference even when no repo context is given', () => {
-    const html = renderMarkdownToSafeHtml('close other-owner/other-repo#1547');
-    expect(html).toContain(
-      'href="https://github.com/other-owner/other-repo/issues/1547"',
-    );
-  });
-
-  it('keeps a URL ending in a numeric fragment as a single link', () => {
-    const html = renderMarkdownToSafeHtml(
-      'see https://github.com/other-owner/other-repo#123',
-      {
-        owner: 'owner',
-        repo: 'repo',
-      },
-    );
-    expect(html).toContain(
-      'href="https://github.com/other-owner/other-repo#123"',
-    );
-    expect(html).not.toContain(
-      'href="https://github.com/other-owner/other-repo/issues/123"',
-    );
-  });
-});
-
-describe('splitMarkdownSegments', () => {
-  it('separates a mermaid fence from surrounding markdown', () => {
-    const segments = splitMarkdownSegments(
-      'intro\n\n```mermaid\ngraph TD; A-->B;\n```\n\noutro',
-    );
-    expect(segments.map(stripKey)).toEqual([
-      { kind: 'markdown', source: 'intro\n' },
-      { kind: 'mermaid', code: 'graph TD; A-->B;' },
-      { kind: 'markdown', source: '\noutro' },
-    ]);
-    expect(new Set(segments.map((segment) => segment.key)).size).toBe(3);
-  });
-
-  it('keeps plain markdown as a single segment', () => {
-    const segments = splitMarkdownSegments('just text');
-    expect(segments.map(stripKey)).toEqual([
-      { kind: 'markdown', source: 'just text' },
-    ]);
-  });
-
-  it('keeps an unterminated mermaid fence as markdown', () => {
-    const segments = splitMarkdownSegments('```mermaid\ngraph TD; A-->B;');
-    expect(segments.map(stripKey)).toEqual([
-      { kind: 'markdown', source: '```mermaid\ngraph TD; A-->B;' },
-    ]);
-  });
-
-  it('keeps a regular fenced code block as a single markdown segment', () => {
-    const segments = splitMarkdownSegments('```ts\nconst answer = 42;\n```');
-    expect(segments.map(stripKey)).toEqual([
-      { kind: 'markdown', source: '```ts\nconst answer = 42;\n```' },
-    ]);
-    const html = renderMarkdownToSafeHtml(
-      (segments[0] as { source: string }).source,
-    );
-    expect(html).toContain('<pre>');
-    expect(html).toContain('<code');
-    expect(html).toContain('const answer = 42;');
-    expect(html).not.toContain('```');
-  });
-
-  it('does not treat a mermaid fence inside a regular code block as a diagram', () => {
-    const segments = splitMarkdownSegments(
-      '```text\n```mermaid\ngraph TD; A-->B;\n```\n```',
-    );
-    expect(segments.map(stripKey)).toEqual([
-      {
-        kind: 'markdown',
-        source: '```text\n```mermaid\ngraph TD; A-->B;\n```\n```',
-      },
-    ]);
-  });
-
-  it('separates a mermaid fence from a following regular code fence', () => {
-    const segments = splitMarkdownSegments(
-      'intro\n\n```mermaid\ngraph TD; A-->B;\n```\n\n```ts\nconst answer = 42;\n```',
-    );
-    expect(segments.map(stripKey)).toEqual([
-      { kind: 'markdown', source: 'intro\n' },
-      { kind: 'mermaid', code: 'graph TD; A-->B;' },
-      { kind: 'markdown', source: '\n```ts\nconst answer = 42;\n```' },
-    ]);
-    const codeSegment = segments[2] as { source: string };
-    const html = renderMarkdownToSafeHtml(codeSegment.source);
-    expect(html).toContain('<pre>');
-    expect(html).toContain('<code');
-    expect(html).not.toContain('```');
-  });
-
-  it('keeps an unterminated regular fence as markdown', () => {
-    const segments = splitMarkdownSegments('```ts\nconst answer = 42;');
-    expect(segments.map(stripKey)).toEqual([
-      { kind: 'markdown', source: '```ts\nconst answer = 42;' },
-    ]);
-  });
-});
-
-describe('hasMermaidFence', () => {
-  it('detects a mermaid fence', () => {
-    expect(hasMermaidFence('```mermaid\ngraph TD; A-->B;\n```')).toBe(true);
-  });
-
-  it('returns false without a mermaid fence', () => {
-    expect(hasMermaidFence('```ts\nconst a = 1;\n```')).toBe(false);
-  });
-});
-
-describe('renderMarkdownToSafeHtml link targets', () => {
-  it('opens an autolinked url in a new tab', () => {
-    const html = renderMarkdownToSafeHtml('https://example.com/doc');
-    expect(html).toContain('target="_blank"');
-    expect(html).toContain('rel="noopener noreferrer"');
-  });
-
-  it('opens an inline markdown link in a new tab', () => {
-    const html = renderMarkdownToSafeHtml('[doc](https://example.com/doc)');
-    expect(html).toContain('target="_blank"');
-    expect(html).toContain('rel="noopener noreferrer"');
-  });
-
-  it('opens an issue reference link in a new tab', () => {
-    const html = renderMarkdownToSafeHtml('see #12', {
-      owner: 'demo',
-      repo: 'repo',
-    });
-    expect(html).toContain('https://github.com/demo/repo/issues/12');
-    expect(html).toContain('target="_blank"');
-  });
-});

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

@@ -1,207 +0,0 @@
-import DOMPurify from 'dompurify';
-import { nameToEmoji } from 'gemoji';
-import { marked, type Tokens } from 'marked';
-import { markedEmoji } from 'marked-emoji';
-import type { ConsoleRepoContext } from '../logic/references';
-
-export type { ConsoleRepoContext } from '../logic/references';
-
-type IssueReferenceToken = Tokens.Generic & {
-  type: 'consoleIssueReference';
-  raw: string;
-  href: string;
-  label: string;
-};
-
-const SAME_REPOSITORY_REFERENCE_PATTERN = /^#(\d+)\b/;
-const CROSS_REPOSITORY_REFERENCE_PATTERN = /^([\w.-]+)\/([\w.-]+)#(\d+)\b/;
-const REFERENCE_START_PATTERN = /[\w.-]+\/[\w.-]+#\d|#\d/g;
-const REFERENCE_PRECEDING_CHARACTER_PATTERN = /[\w/:@-]/;
-
-let activeRepoContext: ConsoleRepoContext | null = null;
-
-const issuesUrl = (owner: string, repo: string, numberText: string): string =>
-  `https://github.com/${owner}/${repo}/issues/${numberText}`;
-
-const isReferenceBoundary = (source: string, index: number): boolean =>
-  index === 0 || !REFERENCE_PRECEDING_CHARACTER_PATTERN.test(source[index - 1]);
-
-const referenceStartIndex = (source: string): number | undefined => {
-  for (const match of source.matchAll(REFERENCE_START_PATTERN)) {
-    if (match.index !== undefined && isReferenceBoundary(source, match.index)) {
-      return match.index;
-    }
-  }
-  return undefined;
-};
-
-const matchIssueReference = (
-  source: string,
-): IssueReferenceToken | undefined => {
-  const crossRepositoryMatch = CROSS_REPOSITORY_REFERENCE_PATTERN.exec(source);
-  if (crossRepositoryMatch !== null) {
-    return {
-      type: 'consoleIssueReference',
-      raw: crossRepositoryMatch[0],
-      href: issuesUrl(
-        crossRepositoryMatch[1],
-        crossRepositoryMatch[2],
-        crossRepositoryMatch[3],
-      ),
-      label: crossRepositoryMatch[0],
-    };
-  }
-  if (activeRepoContext === null) {
-    return undefined;
-  }
-  const sameRepositoryMatch = SAME_REPOSITORY_REFERENCE_PATTERN.exec(source);
-  if (sameRepositoryMatch === null) {
-    return undefined;
-  }
-  return {
-    type: 'consoleIssueReference',
-    raw: sameRepositoryMatch[0],
-    href: issuesUrl(
-      activeRepoContext.owner,
-      activeRepoContext.repo,
-      sameRepositoryMatch[1],
-    ),
-    label: sameRepositoryMatch[0],
-  };
-};
-
-marked.use(
-  markedEmoji({
-    emojis: nameToEmoji,
-    renderer: (token) => token.emoji,
-  }),
-);
-
-marked.use({
-  extensions: [
-    {
-      name: 'consoleIssueReference',
-      level: 'inline',
-      start(src: string) {
-        return referenceStartIndex(src);
-      },
-      tokenizer(src: string): IssueReferenceToken | undefined {
-        return matchIssueReference(src);
-      },
-      renderer(token: Tokens.Generic): string {
-        const reference = token as IssueReferenceToken;
-        return `<a href="${reference.href}">${reference.label}</a>`;
-      },
-    },
-  ],
-});
-
-const withLinksOpeningInNewTab = (html: string): string => {
-  const template = document.createElement('template');
-  template.innerHTML = html;
-  for (const anchor of Array.from(template.content.querySelectorAll('a'))) {
-    anchor.setAttribute('target', '_blank');
-    anchor.setAttribute('rel', 'noopener noreferrer');
-  }
-  return template.innerHTML;
-};
-
-export const renderMarkdownToSafeHtml = (
-  source: string,
-  repoContext?: ConsoleRepoContext,
-): string => {
-  const trimmed = source.trim();
-  if (trimmed === '') {
-    return '';
-  }
-  activeRepoContext = repoContext ?? null;
-  marked.setOptions({ gfm: true, breaks: true });
-  try {
-    const parsed = marked.parse(source, { async: false });
-    const rawHtml = typeof parsed === 'string' ? parsed : '';
-    return withLinksOpeningInNewTab(DOMPurify.sanitize(rawHtml));
-  } finally {
-    activeRepoContext = null;
-  }
-};
-
-export type ConsoleMarkdownSegment =
-  | { kind: 'markdown'; key: string; source: string }
-  | { kind: 'mermaid'; key: string; code: string };
-
-const MERMAID_FENCE = /^```mermaid[^\n]*\n([\s\S]*?)\n```$/;
-
-const isMermaidFenceOpen = (line: string): boolean =>
-  /^```mermaid\s*$/.test(line.trim());
-
-const isCodeFenceOpen = (line: string): boolean =>
-  /^```/.test(line.trim()) && !isMermaidFenceOpen(line);
-
-const isFenceClose = (line: string): boolean => line.trim() === '```';
-
-export const splitMarkdownSegments = (
-  source: string,
-): ConsoleMarkdownSegment[] => {
-  const lines = source.split('\n');
-  const segments: ConsoleMarkdownSegment[] = [];
-  let markdownBuffer: string[] = [];
-  let mermaidBuffer: string[] | null = null;
-  let insideCodeFence = false;
-  let sequence = 0;
-
-  const flushMarkdown = (): void => {
-    if (markdownBuffer.length > 0) {
-      segments.push({
-        kind: 'markdown',
-        key: `markdown:${sequence}`,
-        source: markdownBuffer.join('\n'),
-      });
-      sequence += 1;
-      markdownBuffer = [];
-    }
-  };
-
-  for (const line of lines) {
-    if (insideCodeFence) {
-      markdownBuffer.push(line);
-      if (isFenceClose(line)) {
-        insideCodeFence = false;
-      }
-      continue;
-    }
-    if (mermaidBuffer === null && isMermaidFenceOpen(line)) {
-      flushMarkdown();
-      mermaidBuffer = [];
-      continue;
-    }
-    if (mermaidBuffer !== null) {
-      if (isFenceClose(line)) {
-        segments.push({
-          kind: 'mermaid',
-          key: `mermaid:${sequence}`,
-          code: mermaidBuffer.join('\n'),
-        });
-        sequence += 1;
-        mermaidBuffer = null;
-        continue;
-      }
-      mermaidBuffer.push(line);
-      continue;
-    }
-    if (isCodeFenceOpen(line)) {
-      markdownBuffer.push(line);
-      insideCodeFence = true;
-      continue;
-    }
-    markdownBuffer.push(line);
-  }
-
-  if (mermaidBuffer !== null) {
-    markdownBuffer.push('```mermaid', ...mermaidBuffer);
-  }
-  flushMarkdown();
-  return segments;
-};
-
-export const hasMermaidFence = (source: string): boolean =>
-  /```mermaid\s*\n/.test(source) || MERMAID_FENCE.test(source.trim());

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

@@ -1,27 +0,0 @@
-import { renderMermaidToSvg } from './mermaidLoader';
-
-const initialize = jest.fn();
-const render = jest.fn(async () => ({
-  svg: '<svg><script>alert(1)</script><g></g></svg>',
-}));
-
-describe('renderMermaidToSvg', () => {
-  beforeEach(() => {
-    initialize.mockClear();
-    render.mockClear();
-    (window as unknown as { mermaid: unknown }).mermaid = {
-      initialize,
-      render,
-    };
-  });
-
-  it('initializes mermaid once and returns sanitized svg without scripts', async () => {
-    const first = await renderMermaidToSvg('graph TD; A-->B;');
-    const second = await renderMermaidToSvg('graph TD; C-->D;');
-    expect(initialize).toHaveBeenCalledTimes(1);
-    expect(render).toHaveBeenCalledTimes(2);
-    expect(first).not.toContain('<script>');
-    expect(first).toContain('<svg');
-    expect(second).not.toContain('alert(1)');
-  });
-});

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

@@ -1,71 +0,0 @@
-import DOMPurify from 'dompurify';
-
-type MermaidModule = {
-  initialize: (config: Record<string, unknown>) => void;
-  render: (id: string, code: string) => Promise<{ svg: string }>;
-};
-
-declare global {
-  interface Window {
-    mermaid?: MermaidModule;
-  }
-}
-
-export const MERMAID_SCRIPT_URL =
-  'https://cdn.jsdelivr.net/npm/mermaid@10.9.6/dist/mermaid.min.js';
-
-let mermaidPromise: Promise<MermaidModule> | null = null;
-let renderSequence = 0;
-
-const initializeMermaid = (mermaid: MermaidModule): MermaidModule => {
-  mermaid.initialize({
-    startOnLoad: false,
-    securityLevel: 'strict',
-    theme: 'dark',
-    themeVariables: {
-      background: '#0d1117',
-      primaryColor: '#161b22',
-      primaryTextColor: '#e6edf3',
-      primaryBorderColor: '#30363d',
-      lineColor: '#8b949e',
-      fontSize: '14px',
-    },
-  });
-  return mermaid;
-};
-
-const loadMermaid = (): Promise<MermaidModule> => {
-  if (mermaidPromise !== null) {
-    return mermaidPromise;
-  }
-  if (window.mermaid !== undefined) {
-    mermaidPromise = Promise.resolve(initializeMermaid(window.mermaid));
-    return mermaidPromise;
-  }
-  mermaidPromise = new Promise<MermaidModule>((resolve, reject) => {
-    const script = document.createElement('script');
-    script.src = MERMAID_SCRIPT_URL;
-    script.async = true;
-    script.onload = () => {
-      if (window.mermaid === undefined) {
-        reject(new Error('mermaid failed to load'));
-        return;
-      }
-      resolve(initializeMermaid(window.mermaid));
-    };
-    script.onerror = () => reject(new Error('mermaid script failed to load'));
-    document.head.appendChild(script);
-  });
-  return mermaidPromise;
-};
-
-export const renderMermaidToSvg = async (code: string): Promise<string> => {
-  const mermaid = await loadMermaid();
-  renderSequence += 1;
-  const id = `console-mermaid-${renderSequence}`;
-  const { svg } = await mermaid.render(id, code);
-  return DOMPurify.sanitize(svg, {
-    USE_PROFILES: { svg: true, svgFilters: true },
-    ADD_TAGS: ['foreignObject'],
-  });
-};

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

@@ -1,88 +0,0 @@
-import {
-  clampMermaidZoomScale,
-  formatMermaidZoomScale,
-  isMermaidZoomScaleAtMaximum,
-  isMermaidZoomScaleAtMinimum,
-  MERMAID_ZOOM_MAX_SCALE,
-  MERMAID_ZOOM_MIN_SCALE,
-  MERMAID_ZOOM_SCALE_STEP,
-  mermaidZoomCanvasWidth,
-  mermaidZoomScaleIn,
-  mermaidZoomScaleOut,
-} from './mermaidZoom';
-
-describe('clampMermaidZoomScale', () => {
-  it('keeps a scale inside the range untouched', () => {
-    expect(clampMermaidZoomScale(2.5)).toBe(2.5);
-  });
-
-  it('raises a scale below the minimum to the minimum', () => {
-    expect(clampMermaidZoomScale(0.2)).toBe(MERMAID_ZOOM_MIN_SCALE);
-  });
-
-  it('lowers a scale above the maximum to the maximum', () => {
-    expect(clampMermaidZoomScale(12)).toBe(MERMAID_ZOOM_MAX_SCALE);
-  });
-
-  it('falls back to the minimum for a value that is not a number', () => {
-    expect(clampMermaidZoomScale(Number.NaN)).toBe(MERMAID_ZOOM_MIN_SCALE);
-  });
-});
-
-describe('mermaidZoomScaleIn', () => {
-  it('adds one step', () => {
-    expect(mermaidZoomScaleIn(MERMAID_ZOOM_MIN_SCALE)).toBe(
-      MERMAID_ZOOM_MIN_SCALE + MERMAID_ZOOM_SCALE_STEP,
-    );
-  });
-
-  it('stops at the maximum', () => {
-    expect(mermaidZoomScaleIn(MERMAID_ZOOM_MAX_SCALE)).toBe(
-      MERMAID_ZOOM_MAX_SCALE,
-    );
-  });
-});
-
-describe('mermaidZoomScaleOut', () => {
-  it('subtracts one step', () => {
-    expect(mermaidZoomScaleOut(3)).toBe(3 - MERMAID_ZOOM_SCALE_STEP);
-  });
-
-  it('stops at the minimum', () => {
-    expect(mermaidZoomScaleOut(MERMAID_ZOOM_MIN_SCALE)).toBe(
-      MERMAID_ZOOM_MIN_SCALE,
-    );
-  });
-});
-
-describe('zoom boundary reporting', () => {
-  it('reports the minimum boundary', () => {
-    expect(isMermaidZoomScaleAtMinimum(MERMAID_ZOOM_MIN_SCALE)).toBe(true);
-    expect(isMermaidZoomScaleAtMinimum(MERMAID_ZOOM_MIN_SCALE + 0.5)).toBe(
-      false,
-    );
-  });
-
-  it('reports the maximum boundary', () => {
-    expect(isMermaidZoomScaleAtMaximum(MERMAID_ZOOM_MAX_SCALE)).toBe(true);
-    expect(isMermaidZoomScaleAtMaximum(MERMAID_ZOOM_MAX_SCALE - 0.5)).toBe(
-      false,
-    );
-  });
-});
-
-describe('presentation helpers', () => {
-  it('formats the scale as a percentage', () => {
-    expect(formatMermaidZoomScale(1)).toBe('100%');
-    expect(formatMermaidZoomScale(2.5)).toBe('250%');
-  });
-
-  it('derives the canvas width from the scale', () => {
-    expect(mermaidZoomCanvasWidth(1)).toBe('100%');
-    expect(mermaidZoomCanvasWidth(3)).toBe('300%');
-  });
-
-  it('derives the canvas width from a clamped scale', () => {
-    expect(mermaidZoomCanvasWidth(99)).toBe(`${MERMAID_ZOOM_MAX_SCALE * 100}%`);
-  });
-});

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

@@ -1,34 +0,0 @@
-export const MERMAID_ZOOM_MIN_SCALE = 1;
-export const MERMAID_ZOOM_MAX_SCALE = 6;
-export const MERMAID_ZOOM_SCALE_STEP = 0.5;
-
-export const clampMermaidZoomScale = (scale: number): number => {
-  if (Number.isNaN(scale)) {
-    return MERMAID_ZOOM_MIN_SCALE;
-  }
-  if (scale < MERMAID_ZOOM_MIN_SCALE) {
-    return MERMAID_ZOOM_MIN_SCALE;
-  }
-  if (scale > MERMAID_ZOOM_MAX_SCALE) {
-    return MERMAID_ZOOM_MAX_SCALE;
-  }
-  return scale;
-};
-
-export const mermaidZoomScaleIn = (scale: number): number =>
-  clampMermaidZoomScale(clampMermaidZoomScale(scale) + MERMAID_ZOOM_SCALE_STEP);
-
-export const mermaidZoomScaleOut = (scale: number): number =>
-  clampMermaidZoomScale(clampMermaidZoomScale(scale) - MERMAID_ZOOM_SCALE_STEP);
-
-export const isMermaidZoomScaleAtMinimum = (scale: number): boolean =>
-  clampMermaidZoomScale(scale) <= MERMAID_ZOOM_MIN_SCALE;
-
-export const isMermaidZoomScaleAtMaximum = (scale: number): boolean =>
-  clampMermaidZoomScale(scale) >= MERMAID_ZOOM_MAX_SCALE;
-
-export const formatMermaidZoomScale = (scale: number): string =>
-  `${Math.round(clampMermaidZoomScale(scale) * 100)}%`;
-
-export const mermaidZoomCanvasWidth = (scale: number): string =>
-  `${clampMermaidZoomScale(scale) * 100}%`;

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

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