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

package/src/Markdown/__tests__/MarkdownNesting.a11y.chromium.spec.ts

@@ -1,102 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-// @pr-a11y release-only
-
-/**
- * @file MarkdownNesting.a11y.chromium.spec.ts
- * @input Uses the Core/Markdown Default story, given deeply nested input
- *   through its `children` arg
- * @output Real-Chromium evidence that lists and blockquotes nested thousands
- *   of levels deep render without an error, nested at most 100 deep
- * @position Browser evidence for Markdown's block nesting cap
- */
-
-import {expect, test, type Page} from '@playwright/test';
-import {
-  DEFAULT_STORYBOOK_DIR,
-  serveStorybook,
-  type StaticServer,
-} from '@astryxdesign/a11y-spec/storybook';
-
-const STORYBOOK_DIR = process.env.ASTRYX_STORYBOOK_DIR ?? DEFAULT_STORYBOOK_DIR;
-const STORY = 'core-markdown--default';
-
-let storybook: StaticServer;
-
-test.beforeAll(async () => {
-  storybook = await serveStorybook(STORYBOOK_DIR);
-});
-
-test.afterAll(async () => {
-  await storybook?.close();
-});
-
-/** Opens the story and renders `markdown` in it; returns the page errors. */
-async function renderMarkdown(page: Page, markdown: string): Promise<string[]> {
-  const errors: string[] = [];
-  page.on('pageerror', error => errors.push(String(error)));
-  page.on('console', message => {
-    if (message.type() === 'error' && !message.text().includes('404')) {
-      errors.push(message.text());
-    }
-  });
-  await page.goto(
-    `${storybook.origin}/iframe.html?id=${STORY}&viewMode=story&globals=astryxTheme:neutral;colorMode:light;direction:ltr`,
-    {waitUntil: 'load'},
-  );
-  await expect(page.locator('#storybook-root')).not.toBeEmpty();
-  await page.evaluate(
-    ({storyId, children}) => {
-      const channel = (
-        window as Window & {
-          __STORYBOOK_ADDONS_CHANNEL__?: {
-            emit(event: string, payload: unknown): void;
-          };
-        }
-      ).__STORYBOOK_ADDONS_CHANNEL__;
-      channel?.emit('updateStoryArgs', {storyId, updatedArgs: {children}});
-    },
-    {storyId: STORY, children: markdown},
-  );
-  return errors;
-}
-
-/** How deep lists and blockquotes nest in the rendered story. */
-async function renderedDepth(page: Page): Promise<number> {
-  return page.locator('#storybook-root').evaluate(root => {
-    let deepest = 0;
-    const stack: {element: Element; depth: number}[] = [
-      {element: root, depth: 0},
-    ];
-    while (stack.length > 0) {
-      const {element, depth} = stack.pop() as {element: Element; depth: number};
-      const next = ['UL', 'OL', 'BLOCKQUOTE'].includes(element.tagName)
-        ? depth + 1
-        : depth;
-      deepest = Math.max(deepest, next);
-      for (const child of element.children) {
-        stack.push({element: child, depth: next});
-      }
-    }
-    return deepest;
-  });
-}
-
-test.describe('Markdown renders deeply nested input', () => {
-  for (const [name, markdown] of [
-    ['a list 10,000 deep', `${'- '.repeat(10_000)}deepest`],
-    ['a blockquote 10,000 deep', `${'> '.repeat(10_000)}deepest`],
-    [
-      'lists and blockquotes 10,000 deep',
-      `${Array.from({length: 10_000}, (_, level) => (level % 2 === 0 ? '> ' : '- ')).join('')}deepest`,
-    ],
-  ] as const) {
-    test(`${name}, nested at most 100 deep, with no error`, async ({page}) => {
-      const errors = await renderMarkdown(page, markdown);
-      await expect(page.locator('#storybook-root')).toContainText('deepest');
-      const depth = await renderedDepth(page);
-      expect(depth).toBeGreaterThan(50);
-      expect(depth).toBeLessThanOrEqual(100);
-      expect(errors).toEqual([]);
-    });
-  }
-});

package/src/Markdown/angleDestinations.test.tsx

@@ -1,104 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {parseInlineAst} from './parser';
-import {isSafeMarkdownParserUrl} from './url';
-
-type Json = {type: string; url?: string; value?: string; children?: Json[]};
-
-/** Each link or image as `type(url)`, in order. */
-function targets(markdown: string): string[] {
-  const found: string[] = [];
-  const visit = (node: Json) => {
-    if (node.type === 'link' || node.type === 'image') {
-      found.push(`${node.type}(${node.url})`);
-    }
-    (node.children ?? []).forEach(visit);
-  };
-  (parseInlineAst(markdown) as unknown as Json[]).forEach(visit);
-  return found;
-}
-
-describe('angle-bracket destinations (CommonMark 0.31 §6.3)', () => {
-  it.each([
-    ['[a](<b(c>)', ['link(b(c)']],
-    ['[a](<b(c> "t")', ['link(b(c)']],
-    ['[a](< b(c) d >)', ['link( b(c) d )']],
-    ['![i](<b(c>)', ['image(b(c)']],
-    ['[a](<b\\>c>)', ['link(b>c)']],
-    ['[a](<b\\<c>)', ['link(b<c)']],
-    ['[a](<>)', ['link()']],
-    ['[a](<b\nc>)', []],
-    ['[a](<b>c>)', []],
-    ['![i](<b>c>)', []],
-    ['[a](<b)', []],
-    ['[a](<b c)', []],
-    ['[link](<foo\\>)', []],
-    ['[a](<b<c>)', []],
-    ['[a](<b\\\nc>)', []],
-    ['[a](b c)', ['link(b c)']],
-    ['[a](<b(c>) and [d](e)', ['link(b(c)', 'link(e)']],
-  ])('reads %j', (markdown, expected) => {
-    expect(targets(markdown)).toEqual(expected);
-  });
-
-  it('refuses every unsafe scheme, however its angle destination is written', () => {
-    let state = 31;
-    const random = () => {
-      state = (state * 1103515245 + 12345) % 2147483648;
-      return state / 2147483648;
-    };
-    const pick = <T,>(items: ReadonlyArray<T>): T =>
-      items[Math.floor(random() * items.length)];
-    const schemes = [
-      'javascript:',
-      'JaVaScRiPt:',
-      '&#106;avascript:',
-      '&#x6A;avascript:',
-      'java\\script:',
-      'vbscript:',
-      'data:text/html,',
-      'data: text/html,',
-      'data:&#32;text/html,',
-    ];
-    for (let round = 0; round < 500; round++) {
-      const body = pick([
-        'x',
-        'a(b)',
-        'a(b',
-        'a\\>b',
-        'a\\<b',
-        ' x ',
-        '',
-        'a>b',
-        'a<b',
-        'a\\',
-        'a\\\nb',
-      ]);
-      const title = pick(['', ' "t"', " 't'", ' (t)']);
-      const markdown = `${pick(['[a]', '![a]'])}(${pick(['', ' '])}<${pick(schemes)}${body}>${title})`;
-      for (const target of targets(markdown)) {
-        const url = target.slice(target.indexOf('(') + 1, -1);
-        expect(isSafeMarkdownParserUrl(url), markdown).toBe(true);
-      }
-    }
-  });
-
-  it('finds angle destinations in linear time', () => {
-    for (const markdown of [
-      '[a](<b '.repeat(20_000),
-      '[a](<b> ('.repeat(20_000),
-      '[a](<b> "'.repeat(20_000),
-    ]) {
-      parseInlineAst(markdown);
-      let fastest = Number.POSITIVE_INFINITY;
-      for (let round = 0; round < 3; round++) {
-        const started = performance.now();
-        parseInlineAst(markdown);
-        fastest = Math.min(fastest, performance.now() - started);
-      }
-      // The budget leaves room for a loaded test machine.
-      expect(fastest, markdown.slice(0, 12)).toBeLessThan(1000);
-    }
-  });
-});

package/src/Markdown/ast.test.ts

@@ -1,374 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {
-  createIncrementalState,
-  parseMarkdown,
-  parseMarkdownAst,
-} from './parser';
-import {markdownAstText} from './ast';
-import {createMarkdownPlugin} from './plugins';
-import type {
-  MarkdownExtensionNode,
-  MarkdownSyntaxPluginDefinition,
-} from './plugins';
-
-type DemoNoteNode = MarkdownExtensionNode<
-  'demo-notes',
-  'note',
-  {readonly body: string},
-  'block'
->;
-
-const demoNotes = createMarkdownPlugin<'demo-notes', DemoNoteNode>({
-  name: 'demo-notes',
-  apiVersion: 1,
-  parseKey: 'v1',
-  syntax: {
-    block: [
-      {
-        startsWith: [':::note'],
-        maxSpan: 200,
-        tokenize({source, offset, end, isFinal}) {
-          const close = source.indexOf('\n:::', offset + 7);
-          if (close < 0 || close + 4 > end) {
-            return isFinal ? {status: 'no-match'} : {status: 'defer'};
-          }
-          return {
-            status: 'match',
-            end: close + 4,
-            node: {
-              type: 'extension',
-              plugin: 'demo-notes',
-              name: 'note',
-              display: 'block',
-              data: {body: source.slice(offset + 7, close).trim()},
-            },
-          };
-        },
-      },
-    ],
-  },
-  renderers: {
-    note: {
-      render: ({node}) => node.data.body,
-      toText: node => node.data.body,
-    },
-  },
-} satisfies MarkdownSyntaxPluginDefinition<'demo-notes', DemoNoteNode>);
-
-describe('canonical Markdown AST', () => {
-  it('uses MDAST-aligned names and fields for every built-in structure', () => {
-    const ast = parseMarkdownAst(
-      '# Title\n\n**bold** and *emphasis* with `code` and [link](/docs).\n\n- item\n\n| A | B |\n| - | - |\n| 1 | 2 |\n\n```ts\nconst value = 1;\n```\n\n---',
-    );
-
-    expect(ast).toMatchObject({
-      type: 'root',
-      children: [
-        {
-          type: 'heading',
-          depth: 1,
-          children: [{type: 'text', value: 'Title'}],
-        },
-        {
-          type: 'paragraph',
-          children: [
-            {type: 'strong'},
-            {type: 'text'},
-            {type: 'emphasis'},
-            {type: 'text'},
-            {type: 'inlineCode', value: 'code'},
-            {type: 'text'},
-            {type: 'link', url: '/docs'},
-            {type: 'text', value: '.'},
-          ],
-        },
-        {
-          type: 'list',
-          ordered: false,
-          children: [{type: 'listItem'}],
-        },
-        {
-          type: 'table',
-          align: [null, null],
-          children: [
-            {
-              type: 'tableRow',
-              children: [{type: 'tableCell'}, {type: 'tableCell'}],
-            },
-            {
-              type: 'tableRow',
-              children: [{type: 'tableCell'}, {type: 'tableCell'}],
-            },
-          ],
-        },
-        {type: 'code', lang: 'ts', value: 'const value = 1;'},
-        {type: 'thematicBreak'},
-      ],
-    });
-  });
-
-  it('represents remaining built-ins without legacy aliases', () => {
-    const ast = parseMarkdownAst(
-      '> quote\n\n![Block](/block.png)\n\nParagraph ![Inline](/inline.png) [src] $x$  \nnext\n\n$$\ny\n$$',
-      {math: true, sourceIds: new Set(['src'])},
-    );
-
-    expect(ast.children).toMatchObject([
-      {
-        type: 'blockquote',
-        children: [
-          {type: 'paragraph', children: [{type: 'text', value: 'quote'}]},
-        ],
-      },
-      {type: 'image', url: '/block.png', alt: 'Block'},
-      {
-        type: 'paragraph',
-        children: [
-          {type: 'text', value: 'Paragraph '},
-          {type: 'image', url: '/inline.png', alt: 'Inline'},
-          {type: 'text', value: ' '},
-          {type: 'citation', sourceId: 'src'},
-          {type: 'text', value: ' '},
-          {type: 'inlineMath', value: 'x'},
-          {type: 'break'},
-          {type: 'text', value: 'next'},
-        ],
-      },
-      {type: 'math', value: 'y'},
-    ]);
-    expect(parseMarkdownAst('```\nplain\n```').children[0]).toMatchObject({
-      type: 'code',
-      lang: null,
-      value: 'plain',
-    });
-    expect(parseMarkdown('```\nplain\n```')[0]).toEqual({
-      type: 'codeblock',
-      language: 'plaintext',
-      content: 'plain',
-    });
-  });
-
-  it('keeps lazy continuation text and source provenance in its owning block', () => {
-    const source = '> quoted\ncontinued lazily';
-    const ast = parseMarkdownAst(source);
-    const quote = ast.children[0];
-
-    expect(ast.children).toHaveLength(1);
-    expect(quote).toMatchObject({
-      type: 'blockquote',
-      position: {start: {offset: 0}, end: {offset: source.length}},
-      children: [
-        {
-          type: 'paragraph',
-          children: [{type: 'text', value: 'quoted\ncontinued lazily'}],
-        },
-      ],
-    });
-    if (quote?.type !== 'blockquote') {
-      throw new Error('Expected blockquote');
-    }
-    const paragraph = quote.children[0];
-    if (paragraph?.type !== 'paragraph') {
-      throw new Error('Expected paragraph');
-    }
-    expect(markdownAstText(paragraph.children, () => '')).toBe(
-      'quoted\ncontinued lazily',
-    );
-    expect(parseMarkdown(source, {sourceRanges: true})[0]?.range).toEqual({
-      start: 0,
-      end: source.length,
-    });
-
-    const listSource = '- listed\ncontinued lazily';
-    const list = parseMarkdownAst(listSource).children[0];
-    expect(list).toMatchObject({
-      type: 'list',
-      position: {start: {offset: 0}, end: {offset: listSource.length}},
-      children: [
-        {
-          type: 'listItem',
-          children: [
-            {
-              type: 'paragraph',
-              children: [{type: 'text', value: 'listed\ncontinued lazily'}],
-            },
-          ],
-        },
-      ],
-    });
-  });
-
-  it('lets block plugin syntax interrupt a lazy continuation', () => {
-    const ast = parseMarkdownAst('> quoted\n:::note\nBody\n:::', {
-      plugins: [demoNotes],
-    });
-
-    expect(ast.children).toMatchObject([
-      {type: 'blockquote'},
-      {
-        type: 'extension',
-        plugin: 'demo-notes',
-        name: 'note',
-        data: {body: 'Body'},
-      },
-    ]);
-  });
-
-  it('keeps source provenance canonical while projecting the released range', () => {
-    const source = '# Heading\n\nParagraph';
-    const ast = parseMarkdownAst(source, {sourceRanges: true});
-    const legacy = parseMarkdown(source, {sourceRanges: true});
-
-    expect(ast.children[0].position).toEqual({
-      start: {offset: 0},
-      end: {offset: 9},
-    });
-    expect(legacy[0]).toEqual({
-      type: 'heading',
-      level: 1,
-      children: [{type: 'text', content: 'Heading'}],
-      range: {start: 0, end: 9},
-    });
-    expect('position' in legacy[0]).toBe(false);
-  });
-
-  it('authors canonical positions without the sourceRanges option', () => {
-    const source = '# Heading\n\nParagraph\n\n> Quoted';
-    const ast = parseMarkdownAst(source);
-
-    // Transforms observe provenance on every top-level block whether or not
-    // the caller opted into the released `range` projection.
-    expect(ast.children.map(block => block.position)).toEqual([
-      {start: {offset: 0}, end: {offset: 9}},
-      {start: {offset: 11}, end: {offset: 20}},
-      {start: {offset: 22}, end: {offset: 30}},
-    ]);
-    expect(
-      parseMarkdownAst(source, {sourceRanges: true}).children.map(
-        block => block.position,
-      ),
-    ).toEqual(ast.children.map(block => block.position));
-
-    // Nested blocks remain a top-level-only contract.
-    const quote = ast.children[2];
-    if (quote.type !== 'blockquote') {
-      throw new Error('Expected blockquote');
-    }
-    expect(quote.children[0].position).toBeUndefined();
-
-    // The released projection is unchanged: no `range` unless asked for.
-    expect(parseMarkdown(source)).toEqual([
-      {
-        type: 'heading',
-        level: 1,
-        children: [{type: 'text', content: 'Heading'}],
-      },
-      {type: 'paragraph', children: [{type: 'text', content: 'Paragraph'}]},
-      {
-        type: 'blockquote',
-        children: [
-          {type: 'paragraph', children: [{type: 'text', content: 'Quoted'}]},
-        ],
-      },
-    ]);
-  });
-
-  it('keeps canonical positions off released extension nodes', () => {
-    const source = ':::note\nBody\n:::\n\nTail prose.';
-    const plugins = [demoNotes];
-
-    // The projection rebuilds every built-in block field by field, but passes
-    // an extension node through — so it is the one kind that could carry a
-    // canonical position out. Without the option the released node is exactly
-    // what it has always been.
-    const released = parseMarkdown(source, {plugins});
-    expect(released[0]).toEqual({
-      type: 'extension',
-      plugin: 'demo-notes',
-      name: 'note',
-      display: 'block',
-      data: {body: 'Body'},
-      source: ':::note\nBody\n:::',
-    });
-    expect('position' in released[0]).toBe(false);
-    expect(Object.keys(released[0])).toEqual([
-      'type',
-      'plugin',
-      'name',
-      'display',
-      'data',
-      'source',
-    ]);
-
-    // With the option the node keeps the exact provenance it has always
-    // exposed: `position` with offsets, and no `range`.
-    const withRanges = parseMarkdown(source, {sourceRanges: true, plugins});
-    expect(withRanges[0]).toEqual({
-      type: 'extension',
-      plugin: 'demo-notes',
-      name: 'note',
-      display: 'block',
-      data: {body: 'Body'},
-      source: ':::note\nBody\n:::',
-      position: {start: {offset: 0}, end: {offset: 16}},
-    });
-    expect('range' in withRanges[0]).toBe(false);
-
-    // The canonical tree carries provenance either way.
-    expect(parseMarkdownAst(source, {plugins}).children[0].position).toEqual({
-      start: {offset: 0},
-      end: {offset: 16},
-    });
-  });
-
-  it('preserves optional legacy keys and insertion order exactly', () => {
-    const [image, list] = parseMarkdown('![Alt](/image.png)\n\n- item');
-
-    expect(Object.keys(image)).toEqual(['type', 'alt', 'src']);
-    expect(Object.keys(list)).toEqual([
-      'type',
-      'ordered',
-      'start',
-      'delimiter',
-      'loose',
-      'items',
-    ]);
-    if (list.type !== 'list') {
-      throw new Error('Expected list');
-    }
-    expect(Object.keys(list.items[0])).toEqual(['checked', 'children']);
-    expect(list).toStrictEqual({
-      type: 'list',
-      ordered: false,
-      start: undefined,
-      delimiter: undefined,
-      loose: undefined,
-      items: [
-        {
-          checked: undefined,
-          children: [
-            {
-              type: 'paragraph',
-              children: [{type: 'text', content: 'item'}],
-            },
-          ],
-        },
-      ],
-    });
-  });
-
-  it('does not expose canonical fields through released parser results', () => {
-    const state = createIncrementalState();
-    const blocks = parseMarkdown('# Heading\n\nParagraph');
-
-    expect(blocks[0]).toEqual({
-      type: 'heading',
-      level: 1,
-      children: [{type: 'text', content: 'Heading'}],
-    });
-    expect('depth' in blocks[0]).toBe(false);
-    expect(state.settledBlocks).toEqual([]);
-  });
-});

package/src/Markdown/atxHeadingIndentation.test.tsx

@@ -1,53 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {
-  createIncrementalState,
-  parseMarkdown,
-  parseMarkdownAst,
-  parseMarkdownIncremental,
-} from './parser';
-
-type Json = {type: string; value?: string; depth?: number; children?: Json[]};
-
-/** The document's blocks as compact markup. */
-function blocks(markdown: string): string {
-  const show = (node: Json): string =>
-    node.type === 'text'
-      ? JSON.stringify(node.value)
-      : node.children == null
-        ? node.type
-        : `${node.type}${node.depth ?? ''}[${node.children.map(show).join(', ')}]`;
-  return (parseMarkdownAst(markdown).children as unknown as Json[])
-    .map(show)
-    .join(' | ');
-}
-
-describe('an ATX heading may be indented up to three spaces (CommonMark 0.31 §4.2)', () => {
-  it.each([
-    ['three spaces', '   # h', 'heading1["h"]'],
-    ['one space, second level', ' ## h', 'heading2["h"]'],
-    [
-      'two spaces, interrupting a paragraph',
-      'text\n  # h',
-      'paragraph["text"] | heading1["h"]',
-    ],
-    ['no indentation, unchanged', '# h', 'heading1["h"]'],
-  ])('reads %s as a heading', (_, markdown, expected) => {
-    expect(blocks(markdown)).toBe(expected);
-  });
-
-  it('reads four spaces of indentation as no heading', () => {
-    expect(blocks('    # h')).not.toContain('heading');
-  });
-
-  it('streams indented headings to the full parse at every character', () => {
-    const markdown = 'a\n\n   # one\n\ntext\n  ## two\n';
-    const state = createIncrementalState();
-    let streamed = parseMarkdownIncremental('', state);
-    for (let end = 1; end <= markdown.length; end++) {
-      streamed = parseMarkdownIncremental(markdown.slice(0, end), state);
-    }
-    expect(streamed).toEqual(parseMarkdown(markdown));
-  });
-});