@astryxdesign/core 0.6.2 → 0.6.3-canary.0788c49

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

@@ -0,0 +1,103 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file parser.public.test.ts
+ * @input Imports the documented Markdown parser-only package subpath
+ * @output Runtime and type evidence for its canonical server-safe contract
+ * @position Public package-contract test for @astryxdesign/core/Markdown/parser
+ */
+
+import {readFileSync} from 'node:fs';
+import {join} from 'node:path';
+import {describe, expect, expectTypeOf, it} from 'vitest';
+import {
+  createMarkdownFrontmatter,
+  createMarkdownPlugin,
+} from '@astryxdesign/core/Markdown/plugins';
+import {
+  createIncrementalState,
+  parseInline,
+  parseInlineAst,
+  parseMarkdown,
+  parseMarkdownAst,
+  parseMarkdownIncremental,
+} from '@astryxdesign/core/Markdown/parser';
+import type {
+  BlockNode,
+  InlineNode,
+  MarkdownAstPhrasingContent,
+  MarkdownAstRoot,
+} from '@astryxdesign/core/Markdown/parser';
+
+describe('@astryxdesign/core/Markdown/parser', () => {
+  it('is a generated public package subpath', () => {
+    const packageJson = JSON.parse(
+      readFileSync(join(process.cwd(), 'packages/core/package.json'), 'utf8'),
+    ) as {
+      exports: Record<string, unknown>;
+    };
+    const entrySources = [
+      'packages/core/src/Markdown/parser/index.ts',
+      'packages/core/src/Markdown/parser.ts',
+      'packages/core/src/Markdown/plugins/index.ts',
+      'packages/core/src/Markdown/plugins/protocol.ts',
+      'packages/core/src/Markdown/plugins/frontmatter.ts',
+    ].map(path => readFileSync(join(process.cwd(), path), 'utf8'));
+
+    expect(packageJson.exports['./Markdown/parser']).toEqual({
+      source: './src/Markdown/parser/index.ts',
+      types: './dist/Markdown/parser/index.d.ts',
+      default: './dist/Markdown/parser/index.js',
+    });
+    for (const entrySource of entrySources) {
+      expect(entrySource).not.toMatch(/^\s*['"]use client['"]/m);
+    }
+  });
+
+  it('exposes legacy and canonical parser results from a server-only entry point', () => {
+    const source = '# Heading\n\nParagraph';
+    const blockAst = parseMarkdownAst(source);
+    const inlineAst = parseInlineAst('**bold**');
+
+    expect(blockAst).toMatchObject({
+      type: 'root',
+      children: [{type: 'heading', depth: 1}, {type: 'paragraph'}],
+    });
+    expect(inlineAst).toMatchObject([{type: 'strong'}]);
+    expect(parseMarkdown(source)[0]).toMatchObject({type: 'heading', level: 1});
+    expect(parseInline('**bold**')[0]).toMatchObject({type: 'bold'});
+    expect(parseMarkdownIncremental(source, createIncrementalState())).toEqual(
+      parseMarkdown(source),
+    );
+
+    const canonicalBlockAst: MarkdownAstRoot = blockAst;
+    const canonicalInlineAst: ReadonlyArray<MarkdownAstPhrasingContent> =
+      inlineAst;
+    expect(canonicalBlockAst).toBe(blockAst);
+    expect(canonicalInlineAst).toBe(inlineAst);
+    expectTypeOf(parseMarkdown(source)).toEqualTypeOf<BlockNode[]>();
+    expectTypeOf(parseInline('text')).toEqualTypeOf<InlineNode[]>();
+  });
+
+  it('runs typed plugins through the server-safe parser boundary', () => {
+    const frontmatter = createMarkdownFrontmatter({
+      name: 'server-document-metadata',
+      parse: fields => ({title: fields.title ?? 'Untitled'}),
+    });
+    let title: string | undefined;
+    const observer = createMarkdownPlugin({
+      name: 'server-metadata-observer',
+      apiVersion: 1,
+      transform(root) {
+        title = frontmatter.getMetadata(root)?.title;
+        return root;
+      },
+    });
+    const root = parseMarkdownAst('---\ntitle: Server proof\n---\n# Body', {
+      plugins: [frontmatter.plugin, observer],
+    });
+
+    expect(title).toBe('Server proof');
+    expect(root.children).toMatchObject([{type: 'heading', depth: 1}]);
+  });
+});

package/src/Markdown/parser.test.ts

@@ -42,6 +42,11 @@ describe('parseInline', () => {
     expect(result).toEqual([{type: 'code', content: 'const x'}]);
   });
 
+  it('keeps backslash escapes literal inside standalone inline code', () => {
+    const result = parseInline('`T \\| null`');
+    expect(result).toEqual([{type: 'code', content: 'T \\| null'}]);
+  });
+
   it('leaves math delimiters as literal text by default', () => {
     expect(parseInline('Euler: $e^{i * pi} + 1 = 0$.')).toEqual([
       {type: 'text', content: 'Euler: $e^{i * pi} + 1 = 0$.'},
@@ -165,6 +170,26 @@ describe('parseInline', () => {
     }
   });
 
+  it('decides link destinations with the shared navigation rule', () => {
+    const destinations: [string, boolean][] = [
+      ['https://example.com', true],
+      ['/page', true],
+      ['#section', true],
+      ['mailto:a@example.com', true],
+      ['tel:+1234567890', true],
+      ['custom:document', true],
+      ['data:image/png;base64,iVBORw0KGgo=', true],
+      ['javascript:alert(1)', false],
+      ['vbscript:MsgBox(1)', false],
+      ['data:text/html,<b>x</b>', false],
+      ['java\u0000script:alert(1)', false],
+    ];
+    for (const [destination, accepted] of destinations) {
+      const [node] = parseInline(`[t](${destination})`);
+      expect(node.type === 'link').toBe(accepted);
+    }
+  });
+
   it('parses strikethrough', () => {
     const result = parseInline('~~deleted~~');
     expect(result[0].type).toBe('strikethrough');
@@ -661,17 +686,24 @@ describe('parseMarkdown', () => {
 
   // --- Table with escaped pipes ---
 
-  it('handles escaped pipes in table cells', () => {
+  it('decodes escaped pipes in table code spans without changing prose nodes', () => {
     const input =
-      '| Concept | TypeScript |\n| --- | --- |\n| Null safety | `T \\| null` |\n| Union | `A \\| B \\| C` |';
+      '| Concept | TypeScript |\n| --- | --- |\n| Prose | A \\| B |\n| Null safety | `T \\| null` |\n| Union | `A \\| B \\| C` |';
     const result = parseMarkdown(input);
     expect(result[0].type).toBe('table');
     if (result[0].type === 'table') {
       expect(result[0].headers).toHaveLength(2);
-      expect(result[0].rows).toHaveLength(2);
-      // The cell should contain the escaped pipe as inline content
-      expect(result[0].rows[0]).toHaveLength(2);
-      expect(result[0].rows[1]).toHaveLength(2);
+      expect(result[0].rows).toHaveLength(3);
+      expect(result[0].rows[0][1].children).toEqual([
+        {type: 'text', content: 'A '},
+        {type: 'text', content: '| B'},
+      ]);
+      expect(result[0].rows[1][1].children).toEqual([
+        {type: 'code', content: 'T | null'},
+      ]);
+      expect(result[0].rows[2][1].children).toEqual([
+        {type: 'code', content: 'A | B | C'},
+      ]);
     }
   });