@astryxdesign/core 0.7.5 → 0.7.6-canary.0bd3b37

package/src/Markdown/Markdown.public.test.ts

@@ -1,309 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Markdown.public.test.ts
- * @input Imports Markdown parser, plugin factory, visitor, and node types from the public Markdown and plugin barrels
- * @output Compile-time compatibility coverage for legacy, math-enabled, and plugin results
- * @position Public API test guarding @astryxdesign/core/Markdown and /Markdown/plugins
- */
-
-import {describe, expectTypeOf, it} from 'vitest';
-import {
-  createIncrementalState,
-  decodeMarkdownCharacterReferences,
-  parseInline,
-  parseMarkdown,
-  parseMarkdownIncremental,
-  visitMarkdownNodes,
-} from './index';
-import {decodeMarkdownCharacterReferences as decodeFromParser} from './parser/index';
-import {
-  createMarkdownFenceTransform,
-  createMarkdownHeadingLinks,
-  createMarkdownPlugin,
-  createMarkdownTextTransform,
-  isMarkdownExtensionNode,
-  markdownSoftBreaksPlugin,
-  markdownSourceLinesPlugin,
-} from './plugins';
-import type {
-  MarkdownExtensionNode,
-  MarkdownFenceTransformOptions,
-  MarkdownHeadingLinksOptions,
-  MarkdownPluginEntry,
-  MarkdownSyntaxPluginDefinition,
-  MarkdownTransform,
-} from './plugins';
-import type {
-  BlockNode,
-  BlockNodeWithMath,
-  InlineNode,
-  InlineNodeWithMath,
-  ParseOptions,
-} from './index';
-
-function assertNever(value: never): never {
-  throw new Error(`Unexpected node: ${JSON.stringify(value)}`);
-}
-
-// Existing exhaustive consumers must not gain a new case when they do not opt
-// into math parsing. These functions fail to compile if the legacy unions widen.
-function legacyInlineText(node: InlineNode): string {
-  switch (node.type) {
-    case 'text':
-    case 'code':
-      return node.content;
-    case 'bold':
-    case 'italic':
-    case 'strikethrough':
-    case 'link':
-      return node.children.map(legacyInlineText).join('');
-    case 'image':
-      return node.alt;
-    case 'citation':
-      return node.sourceId;
-    case 'break':
-      return '\n';
-    default:
-      return assertNever(node);
-  }
-}
-
-function legacyBlockText(node: BlockNode): string {
-  switch (node.type) {
-    case 'heading':
-    case 'paragraph':
-      return node.children.map(legacyInlineText).join('');
-    case 'codeblock':
-      return node.content;
-    case 'blockquote':
-      return node.children.map(legacyBlockText).join('\n');
-    case 'list':
-      return node.items
-        .flatMap(item => item.children.map(legacyBlockText))
-        .join('\n');
-    case 'table':
-      return [...node.headers, ...node.rows.flat()]
-        .flatMap(cell => cell.children.map(legacyInlineText))
-        .join(' ');
-    case 'image':
-      return node.alt;
-    case 'hr':
-      return '';
-    default:
-      return assertNever(node);
-  }
-}
-
-describe('decodeMarkdownCharacterReferences entry points (spec:AST-061 DEC-5)', () => {
-  it('is the same function from the Markdown entry and the parser subpath', () => {
-    expectTypeOf(decodeMarkdownCharacterReferences).toEqualTypeOf<
-      (text: string) => string
-    >();
-    expectTypeOf(decodeFromParser).toEqualTypeOf<(text: string) => string>();
-  });
-});
-
-describe('Markdown public parser types', () => {
-  it('keeps default and legacy parser calls on the legacy unions', () => {
-    expectTypeOf(parseInline('plain')).toEqualTypeOf<InlineNode[]>();
-    expectTypeOf(parseInline('plain', new Set<string>())).toEqualTypeOf<
-      InlineNode[]
-    >();
-    expectTypeOf(parseMarkdown('plain')).toEqualTypeOf<BlockNode[]>();
-    expectTypeOf(parseMarkdown('plain', {math: false})).toEqualTypeOf<
-      BlockNode[]
-    >();
-    const annotatedOptions: ParseOptions = {autolink: 'gfm'};
-    expectTypeOf(parseInline('plain', annotatedOptions)).toEqualTypeOf<
-      InlineNode[]
-    >();
-    expectTypeOf(parseMarkdown('plain', annotatedOptions)).toEqualTypeOf<
-      BlockNode[]
-    >();
-    expectTypeOf(
-      parseMarkdownIncremental(
-        'plain',
-        createIncrementalState(),
-        annotatedOptions,
-      ),
-    ).toEqualTypeOf<BlockNode[]>();
-    expectTypeOf(
-      parseMarkdownIncremental('plain', createIncrementalState()),
-    ).toEqualTypeOf<BlockNode[]>();
-    expectTypeOf(createIncrementalState().settledBlocks).toEqualTypeOf<
-      BlockNode[]
-    >();
-    expectTypeOf(legacyInlineText).returns.toBeString();
-    expectTypeOf(legacyBlockText).returns.toBeString();
-  });
-
-  it('rejects ambiguous math options and structurally forged state', () => {
-    function compileOnlyGuards() {
-      const dynamicOptions: {math: boolean} = {math: true};
-      // @ts-expect-error callers must narrow to ParseOptions or MathParseOptions
-      parseMarkdown('$$x$$', dynamicOptions);
-
-      const structuralState = {
-        prevInput: '',
-        settledText: '',
-        settledBlocks: [] as BlockNode[],
-        settledUpTo: 0,
-      };
-      // @ts-expect-error math caches must come from createIncrementalState<true>()
-      parseMarkdownIncremental('$$x$$', structuralState, {math: true});
-    }
-
-    expectTypeOf(compileOnlyGuards).toBeFunction();
-  });
-
-  it('types direct and incremental math opt-ins with explicit math unions', () => {
-    const inline = parseInline('$x$', {math: true});
-    const direct = parseMarkdown('$$x$$', {math: true});
-    const incremental = parseMarkdownIncremental(
-      '$$x$$',
-      createIncrementalState<true>(),
-      {math: true},
-    );
-
-    // A state carries the same node contract as the parser result it caches.
-    // @ts-expect-error math parsing requires a math-enabled incremental state
-    parseMarkdownIncremental('$$x$$', createIncrementalState(), {math: true});
-
-    expectTypeOf(inline).toEqualTypeOf<InlineNodeWithMath[]>();
-    expectTypeOf(direct).toEqualTypeOf<BlockNodeWithMath[]>();
-    expectTypeOf(incremental).toEqualTypeOf<BlockNodeWithMath[]>();
-    expectTypeOf(createIncrementalState<true>().settledBlocks).toEqualTypeOf<
-      BlockNodeWithMath[]
-    >();
-    expectTypeOf<
-      Extract<InlineNodeWithMath, {type: 'math'}>['value']
-    >().toBeString();
-    expectTypeOf<
-      Extract<BlockNodeWithMath, {type: 'math'}>['value']
-    >().toBeString();
-  });
-
-  it('exports typed plugin construction and node-kind visitors', () => {
-    type PublicNode = MarkdownExtensionNode<
-      'public-demo',
-      'token',
-      {readonly label: string},
-      'inline'
-    >;
-    const definition = {
-      name: 'public-demo',
-      apiVersion: 1,
-      parseKey: 'v1',
-      syntax: {
-        inline: [
-          {
-            startsWith: ['::'],
-            maxSpan: 20,
-            tokenize: () => ({status: 'no-match'}) as const,
-          },
-        ],
-      },
-      renderers: {
-        token: {
-          render: () => null,
-          toText: node => node.data.label,
-        },
-      },
-    } satisfies MarkdownSyntaxPluginDefinition<'public-demo', PublicNode>;
-    const plugin = createMarkdownPlugin<'public-demo', PublicNode>(definition);
-    const headingLinksOptions: MarkdownHeadingLinksOptions = {
-      headingIdPrefix: 'article',
-    };
-    const headingLinks = createMarkdownHeadingLinks(headingLinksOptions);
-    const nodes = parseInline('plain', {plugins: [plugin] as const});
-
-    expectTypeOf(nodes).toEqualTypeOf<InlineNode<PublicNode>[]>();
-    expectTypeOf(headingLinks).toEqualTypeOf<MarkdownPluginEntry<never>>();
-    expectTypeOf(createMarkdownHeadingLinks)
-      .parameter(0)
-      .toEqualTypeOf<MarkdownHeadingLinksOptions | undefined>();
-    expectTypeOf(visitMarkdownNodes).toBeFunction();
-    expectTypeOf(createMarkdownTextTransform).toBeFunction();
-    expectTypeOf(markdownSoftBreaksPlugin).toEqualTypeOf<
-      MarkdownPluginEntry<never>
-    >();
-    expectTypeOf(markdownSourceLinesPlugin).toEqualTypeOf<
-      MarkdownPluginEntry<never>
-    >();
-    expectTypeOf(isMarkdownExtensionNode).toBeFunction();
-
-    function compileOnlyPluginGuards() {
-      // @ts-expect-error transforms that own extension nodes require renderers
-      createMarkdownPlugin<'public-demo', PublicNode>({
-        name: 'public-demo',
-        apiVersion: 1,
-        transform: root => root,
-      });
-    }
-    expectTypeOf(compileOnlyPluginGuards).toBeFunction();
-  });
-
-  it('exports a language-narrowed semantic fence transform helper', () => {
-    type PublicFenceNode = MarkdownExtensionNode<
-      'public-semantic-fences',
-      'diagram',
-      {
-        readonly code: string;
-        readonly language: 'mermaid' | 'dot';
-        readonly meta?: string;
-      },
-      'block'
-    >;
-    const options = {
-      languages: ['mermaid', 'dot'] as const,
-      createNode: ({language, code, meta}) => {
-        expectTypeOf(language).toEqualTypeOf<'mermaid' | 'dot'>();
-        expectTypeOf(code).toBeString();
-        expectTypeOf(meta).toEqualTypeOf<string | undefined>();
-        return {
-          type: 'extension',
-          plugin: 'public-semantic-fences',
-          name: 'diagram',
-          display: 'block',
-          data: {
-            code,
-            language,
-            ...(meta == null ? {} : {meta}),
-          },
-        } as const;
-      },
-    } satisfies MarkdownFenceTransformOptions<
-      readonly ['mermaid', 'dot'],
-      PublicFenceNode
-    >;
-    const transform = createMarkdownFenceTransform(options);
-    const plugin = createMarkdownPlugin<
-      'public-semantic-fences',
-      PublicFenceNode
-    >({
-      name: 'public-semantic-fences',
-      apiVersion: 1,
-      transform,
-      renderers: {
-        diagram: {
-          render: () => null,
-          toText: node => node.data.code,
-        },
-      },
-    });
-    const typedTransform: MarkdownTransform<PublicFenceNode> = transform;
-
-    expectTypeOf(typedTransform).toBeFunction();
-    expectTypeOf(plugin).toEqualTypeOf<MarkdownPluginEntry<PublicFenceNode>>();
-
-    function compileOnlyFenceGuards() {
-      createMarkdownFenceTransform({
-        languages: ['mermaid'],
-        // @ts-expect-error fence helpers create data nodes; render belongs in renderers
-        render: () => null,
-      });
-    }
-    expectTypeOf(compileOnlyFenceGuards).toBeFunction();
-  });
-});

package/src/Markdown/Markdown.renderBoundary.test.tsx

@@ -1,72 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Markdown.renderBoundary.test.tsx
- * @input Uses vitest, @testing-library/react, Markdown with a mocked parser
- * @output Tests for the render-side navigation check in Markdown
- * @position Testing; the parser already rejects blocked destinations, so
- *   these tests bypass it and hand the renderer a pre-parsed link node.
- *   That pins the render boundary on its own: it must apply the shared
- *   navigation rule (utils/safeUrl.ts) even when a link node arrives with a
- *   destination the parser never saw.
- */
-
-import {afterEach, describe, expect, it, vi} from 'vitest';
-import {cleanup, render} from '@testing-library/react';
-import {Markdown} from './Markdown';
-import type * as Parser from './parser';
-import type {MarkdownAstBlockContent} from './ast';
-
-const parsed: {blocks: MarkdownAstBlockContent[]} = {blocks: []};
-
-vi.mock('./parser', async importOriginal => {
-  const actual = await importOriginal<typeof Parser>();
-  return {
-    ...actual,
-    parseMarkdownAst: () => ({type: 'root', children: parsed.blocks}),
-  };
-});
-
-function linkParagraph(url: string): MarkdownAstBlockContent[] {
-  return [
-    {
-      type: 'paragraph',
-      children: [{type: 'link', url, children: [{type: 'text', value: 'go'}]}],
-    },
-  ];
-}
-
-afterEach(() => {
-  cleanup();
-});
-
-describe('Markdown render boundary — link destinations', () => {
-  it('renders an accepted pre-parsed destination as a link', () => {
-    parsed.blocks = linkParagraph('data:image/png;base64,iVBORw0KGgo=');
-    const {container} = render(<Markdown>{'ignored'}</Markdown>);
-    expect(container.querySelector('a')?.getAttribute('href')).toBe(
-      'data:image/png;base64,iVBORw0KGgo=',
-    );
-  });
-
-  it.each([
-    'javascript:alert(1)',
-    'vbscript:MsgBox(1)',
-    'data:text/html,<script>alert(1)</script>',
-    'java\nscript:alert(1)',
-  ])('renders a blocked pre-parsed destination %s as text', href => {
-    parsed.blocks = linkParagraph(href);
-    const {container} = render(<Markdown>{'ignored'}</Markdown>);
-    expect(container.querySelector('a')).toBeNull();
-    expect(container.textContent).toContain('go');
-  });
-
-  it('does not hand a blocked destination to a custom link renderer', () => {
-    parsed.blocks = linkParagraph('javascript:alert(1)');
-    const link = vi.fn(({children}: {href: string; children?: unknown}) => (
-      <a data-custom>{children as never}</a>
-    ));
-    render(<Markdown components={{link}}>{'ignored'}</Markdown>);
-    expect(link).not.toHaveBeenCalled();
-  });
-});

package/src/Markdown/Markdown.rerender.test.tsx

@@ -1,143 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Markdown.rerender.test.tsx
- * @input Uses vitest, @testing-library/react, Markdown, a synthetic long document
- * @output Tests that an unrelated caller re-render reuses the rendered document
- * @position Performance regression evidence for long documents. Counting
- *   renders of a caller-supplied block renderer is deterministic, unlike a
- *   timing budget, and fails when Markdown rebuilds every block element on a
- *   re-render that changed nothing it reads.
- */
-
-import {useState} from 'react';
-import {act, cleanup, fireEvent, render} from '@testing-library/react';
-import {afterEach, describe, expect, it, vi} from 'vitest';
-import {Markdown} from './Markdown';
-import type {MarkdownComponents} from './Markdown';
-
-afterEach(() => {
-  cleanup();
-});
-
-/** A long, review-style document: headings, prose, lists, a table, code. */
-function longDocument(sections: number): string {
-  return Array.from({length: sections}, (_, i) =>
-    [
-      `## Section ${i}`,
-      '',
-      `Paragraph ${i} with **bold**, *emphasis*, \`code\` and a [link](/docs/${i}).`,
-      '',
-      `- Point ${i}`,
-      `  - Nested point ${i}`,
-      `- [x] Done ${i}`,
-      '',
-      '| Name | Count |',
-      '| --- | ---: |',
-      `| row ${i} | ${i * 3} |`,
-      '',
-      '```ts',
-      `const value${i} = ${i};`,
-      '```',
-    ].join('\n'),
-  ).join('\n\n');
-}
-
-const SECTIONS = 40;
-
-function createCountingComponents(): {
-  components: Partial<MarkdownComponents>;
-  renders: () => number;
-} {
-  let count = 0;
-  function CountingCode({code}: {code: string; language?: string}) {
-    count++;
-    return <pre data-testid="code">{code}</pre>;
-  }
-  return {components: {code: CountingCode}, renders: () => count};
-}
-
-describe('Markdown re-render reuse', () => {
-  it('does not re-render any block when a caller re-render changes nothing Markdown reads', () => {
-    const {components, renders} = createCountingComponents();
-    const source = longDocument(SECTIONS);
-    let bump: () => void = () => {};
-    function Page() {
-      const [tick, setTick] = useState(0);
-      bump = () => setTick(t => t + 1);
-      return (
-        <section data-tick={tick}>
-          {/* A new link handler each render, as inline callers write it. */}
-          <Markdown components={components} onLinkClick={() => {}}>
-            {source}
-          </Markdown>
-        </section>
-      );
-    }
-    const {container} = render(<Page />);
-    const document = container.querySelector('[role="document"]');
-    const html = document?.innerHTML;
-    expect(renders()).toBe(SECTIONS);
-
-    act(() => bump());
-    act(() => bump());
-
-    expect(renders()).toBe(SECTIONS);
-    expect(container.querySelector('[role="document"]')).toBe(document);
-    expect(document?.innerHTML).toBe(html);
-  });
-
-  it('re-renders when the text changes', () => {
-    const {components, renders} = createCountingComponents();
-    const {rerender, getAllByTestId} = render(
-      <Markdown components={components}>{longDocument(2)}</Markdown>,
-    );
-    expect(renders()).toBe(2);
-    rerender(
-      <Markdown components={components}>
-        {`${longDocument(2)}\n\n\`\`\`ts\nconst added = true;\n\`\`\``}
-      </Markdown>,
-    );
-    expect(getAllByTestId('code')).toHaveLength(3);
-    expect(getAllByTestId('code')[2].textContent).toBe('const added = true;');
-  });
-
-  it('re-renders when a rendering prop changes', () => {
-    const {container, rerender} = render(
-      <Markdown headingLevelStart={1}>{'# Title'}</Markdown>,
-    );
-    expect(container.querySelector('h1')).not.toBeNull();
-    rerender(<Markdown headingLevelStart={3}>{'# Title'}</Markdown>);
-    expect(container.querySelector('h1')).toBeNull();
-    expect(container.querySelector('h3')?.textContent).toBe('Title');
-  });
-
-  it('calls the latest link handler after a re-render that reused the document', () => {
-    const first = vi.fn();
-    const latest = vi.fn(() => false as const);
-    const {container, rerender} = render(
-      <Markdown onLinkClick={first}>{'[go](/next)'}</Markdown>,
-    );
-    rerender(<Markdown onLinkClick={latest}>{'[go](/next)'}</Markdown>);
-    const link = container.querySelector('a');
-    expect(link).not.toBeNull();
-    const event = new MouseEvent('click', {bubbles: true, cancelable: true});
-    act(() => {
-      link?.dispatchEvent(event);
-    });
-    expect(first).not.toHaveBeenCalled();
-    expect(latest).toHaveBeenCalledWith('/next', expect.anything());
-    expect(event.defaultPrevented).toBe(true);
-  });
-
-  it('starts and stops handling link clicks when the handler is added or removed', () => {
-    const handler = vi.fn();
-    const {container, rerender} = render(<Markdown>{'[go](/next)'}</Markdown>);
-    rerender(<Markdown onLinkClick={handler}>{'[go](/next)'}</Markdown>);
-    fireEvent.click(container.querySelector('a') as HTMLAnchorElement);
-    expect(handler).toHaveBeenCalledTimes(1);
-    rerender(<Markdown>{'[go](/next)'}</Markdown>);
-    fireEvent.click(container.querySelector('a') as HTMLAnchorElement);
-    expect(handler).toHaveBeenCalledTimes(1);
-  });
-});