com.wallstop-studios.dxmessaging 2.1.3 → 2.1.5

package/scripts/wiki/__tests__/transform.test.js

@@ -0,0 +1,380 @@
+/**
+ * Test suite for wiki transformation functions
+ */
+
+const {
+    isExternalLink,
+    docsPathToWikiPage,
+    findMarkdownLinks,
+    CodeBlockTracker,
+    transformLine,
+    transformFile
+} = require('../transform-docs-to-wiki.js');
+
+describe('isExternalLink', () => {
+    test('identifies http links', () => {
+        expect(isExternalLink('http://example.com')).toBe(true);
+    });
+
+    test('identifies https links', () => {
+        expect(isExternalLink('https://example.com/path')).toBe(true);
+    });
+
+    test('identifies mailto links', () => {
+        expect(isExternalLink('mailto:test@example.com')).toBe(true);
+    });
+
+    test('identifies tel links', () => {
+        expect(isExternalLink('tel:+1234567890')).toBe(true);
+    });
+
+    test('identifies ftp links', () => {
+        expect(isExternalLink('ftp://files.example.com')).toBe(true);
+    });
+
+    test('identifies relative paths as internal', () => {
+        expect(isExternalLink('./file.md')).toBe(false);
+        expect(isExternalLink('../file.md')).toBe(false);
+        expect(isExternalLink('file.md')).toBe(false);
+    });
+
+    test('identifies absolute paths as internal', () => {
+        expect(isExternalLink('/docs/file.md')).toBe(false);
+    });
+});
+
+describe('docsPathToWikiPage', () => {
+    test('converts simple path', () => {
+        expect(docsPathToWikiPage('concepts/message-types.md')).toBe('Concepts-Message-Types');
+    });
+
+    test('converts nested path', () => {
+        expect(docsPathToWikiPage('getting-started/overview.md')).toBe('Getting-Started-Overview');
+    });
+
+    test('converts index.md to parent directory name', () => {
+        expect(docsPathToWikiPage('concepts/index.md')).toBe('Concepts');
+    });
+
+    test('converts nested index.md to parent path', () => {
+        expect(docsPathToWikiPage('advanced/topics/index.md')).toBe('Advanced-Topics');
+    });
+
+    test('converts root index.md to Home', () => {
+        expect(docsPathToWikiPage('index.md')).toBe('Home');
+    });
+
+    test('converts README.md to Home', () => {
+        expect(docsPathToWikiPage('README.md')).toBe('Home');
+    });
+
+    test('handles parent directory README reference', () => {
+        expect(docsPathToWikiPage('../README.md')).toBe('Home');
+    });
+
+    test('capitalizes each path segment', () => {
+        expect(docsPathToWikiPage('guides/testing.md')).toBe('Guides-Testing');
+    });
+
+    test('handles paths without .md extension', () => {
+        expect(docsPathToWikiPage('concepts/types')).toBe('Concepts-Types');
+    });
+});
+
+describe('CodeBlockTracker', () => {
+    let tracker;
+
+    beforeEach(() => {
+        tracker = new CodeBlockTracker();
+    });
+
+    test('tracks triple backtick code blocks', () => {
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('code here')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('tracks code blocks with language', () => {
+        expect(tracker.processLine('```javascript')).toBe(true);
+        expect(tracker.processLine('const x = 1;')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('tracks code blocks with csharp language', () => {
+        expect(tracker.processLine('```csharp')).toBe(true);
+        expect(tracker.processLine('public class Test {}')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('tracks quadruple backtick code blocks', () => {
+        expect(tracker.processLine('````')).toBe(true);
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('nested')).toBe(true);
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('````')).toBe(false);
+    });
+
+    test('tracks tilde code blocks', () => {
+        expect(tracker.processLine('~~~')).toBe(true);
+        expect(tracker.processLine('code')).toBe(true);
+        expect(tracker.processLine('~~~')).toBe(false);
+    });
+
+    test('does not close backtick block with tildes', () => {
+        expect(tracker.processLine('```')).toBe(true);
+        expect(tracker.processLine('~~~')).toBe(true);
+        expect(tracker.processLine('```')).toBe(false);
+    });
+
+    test('reset clears state', () => {
+        tracker.processLine('```');
+        expect(tracker.inCodeBlock).toBe(true);
+        tracker.reset();
+        expect(tracker.inCodeBlock).toBe(false);
+    });
+
+    test('handles indented code fences', () => {
+        expect(tracker.processLine('    ```python')).toBe(true);
+        expect(tracker.processLine('    print("hello")')).toBe(true);
+        expect(tracker.processLine('    ```')).toBe(false);
+    });
+});
+
+describe('findMarkdownLinks', () => {
+    test('finds simple link', () => {
+        const links = findMarkdownLinks('See [guide](guide.md) for more.');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('guide');
+        expect(links[0].href).toBe('guide.md');
+        expect(links[0].isImage).toBe(false);
+    });
+
+    test('finds multiple links', () => {
+        const links = findMarkdownLinks('[one](a.md) and [two](b.md)');
+        expect(links).toHaveLength(2);
+        expect(links[0].text).toBe('one');
+        expect(links[0].href).toBe('a.md');
+        expect(links[1].text).toBe('two');
+        expect(links[1].href).toBe('b.md');
+    });
+
+    test('finds image links', () => {
+        const links = findMarkdownLinks('![alt text](image.png)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('alt text');
+        expect(links[0].href).toBe('image.png');
+        expect(links[0].isImage).toBe(true);
+    });
+
+    test('finds links with anchors', () => {
+        const links = findMarkdownLinks('[section](page.md#heading)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('page.md#heading');
+    });
+
+    test('ignores links inside inline code', () => {
+        const links = findMarkdownLinks('Use `[link](file.md)` syntax');
+        expect(links).toHaveLength(0);
+    });
+
+    test('ignores links inside double-backtick inline code', () => {
+        const links = findMarkdownLinks('Use ``[link](file.md)`` syntax');
+        expect(links).toHaveLength(0);
+    });
+
+    test('ignores links inside double-backtick with text before', () => {
+        const links = findMarkdownLinks('Some text ``[link](file.md)`` more text');
+        expect(links).toHaveLength(0);
+    });
+
+    test('finds real link after double-backtick inline code', () => {
+        const links = findMarkdownLinks('Use ``code`` then [real](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('real');
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('ignores links inside triple-backtick inline code', () => {
+        const links = findMarkdownLinks('Use ```[link](file.md)``` syntax');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles mixed single and double backtick code spans', () => {
+        const links = findMarkdownLinks('`single` and ``double [link](file.md)`` and [real](page.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('real');
+        expect(links[0].href).toBe('page.md');
+    });
+
+    test('handles unclosed multi-backtick delimiter', () => {
+        const links = findMarkdownLinks('Text ``unclosed [link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('handles asymmetric backticks correctly', () => {
+        // Double open, single close - should not match, link should be found
+        const links = findMarkdownLinks('Text ``code` [link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('finds links with nested brackets in text', () => {
+        const links = findMarkdownLinks('[[nested]](page.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('[nested]');
+    });
+
+    test('finds links with parentheses in href', () => {
+        const links = findMarkdownLinks('[link](page_(version).md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('page_(version).md');
+    });
+
+    test('returns empty array for no links', () => {
+        const links = findMarkdownLinks('No links here');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles escaped brackets', () => {
+        const links = findMarkdownLinks('\\[not a link\\](file.md)');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles empty code span before link', () => {
+        const links = findMarkdownLinks('`` `` then [link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('link');
+        expect(links[0].href).toBe('file.md');
+    });
+
+    test('handles very long backtick sequences', () => {
+        const links = findMarkdownLinks('``````````[link](file.md)``````````');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles backticks at end of line with no close', () => {
+        const links = findMarkdownLinks('text with unclosed ``');
+        expect(links).toHaveLength(0);
+    });
+
+    test('handles backtick immediately before link', () => {
+        const links = findMarkdownLinks('`[link](file.md)');
+        expect(links).toHaveLength(1);
+        expect(links[0].text).toBe('link');
+        expect(links[0].href).toBe('file.md');
+    });
+});
+
+describe('transformLine', () => {
+    test('transforms internal markdown link to wiki link', () => {
+        const result = transformLine('[Guide](guide.md)', 'index.md');
+        // When link text matches wiki page name, simple [[Page]] format is used
+        expect(result).toBe('[[Guide]]');
+    });
+
+    test('preserves external links', () => {
+        const result = transformLine('[GitHub](https://github.com)', 'index.md');
+        expect(result).toBe('[GitHub](https://github.com)');
+    });
+
+    test('preserves anchor-only links', () => {
+        const result = transformLine('[Section](#section)', 'index.md');
+        expect(result).toBe('[Section](#section)');
+    });
+
+    test('transforms links with anchors', () => {
+        const result = transformLine('[Topic](concepts/types.md#section)', 'index.md');
+        expect(result).toBe('[[Concepts-Types#section|Topic]]');
+    });
+
+    test('transforms relative paths correctly', () => {
+        // Note: Path resolution happens at a different level, '../index.md' becomes '..' page
+        const result = transformLine('[Back](../index.md)', 'concepts/types.md');
+        expect(result).toBe('[[..|Back]]');
+    });
+
+    test('handles multiple links in one line', () => {
+        const result = transformLine('[One](a.md) and [Two](b.md)', 'index.md');
+        expect(result).toContain('[[A|One]]');
+        expect(result).toContain('[[B|Two]]');
+    });
+
+    test('transforms image paths', () => {
+        const result = transformLine('![Image](images/diagram.png)', 'index.md');
+        expect(result).toBe('![Image](wiki-images/diagram.png)');
+    });
+
+    test('preserves external image links', () => {
+        const result = transformLine('![Badge](https://img.shields.io/badge.svg)', 'index.md');
+        expect(result).toBe('![Badge](https://img.shields.io/badge.svg)');
+    });
+
+    test('returns unchanged line with no links', () => {
+        const result = transformLine('Just some text', 'index.md');
+        expect(result).toBe('Just some text');
+    });
+});
+
+describe('transformFile', () => {
+    test('preserves code blocks', () => {
+        const content = `# Example
+
+\`\`\`markdown
+[This should not be transformed](link.md)
+\`\`\`
+
+[This should be transformed](link.md)`;
+
+        const result = transformFile(content, 'index.md');
+        expect(result).toContain('[This should not be transformed](link.md)');
+        expect(result).toContain('[[Link|This should be transformed]]');
+    });
+
+    test('handles multiple code blocks', () => {
+        const content = `[before](a.md)
+
+\`\`\`
+[inside1](b.md)
+\`\`\`
+
+[between](c.md)
+
+\`\`\`csharp
+[inside2](d.md)
+\`\`\`
+
+[after](e.md)`;
+
+        const result = transformFile(content, 'index.md');
+        expect(result).toContain('[[A|before]]');
+        expect(result).toContain('[inside1](b.md)');
+        expect(result).toContain('[[C|between]]');
+        expect(result).toContain('[inside2](d.md)');
+        expect(result).toContain('[[E|after]]');
+    });
+
+    test('preserves line structure', () => {
+        const content = `Line 1
+Line 2
+Line 3`;
+
+        const result = transformFile(content, 'index.md');
+        const lines = result.split('\n');
+        expect(lines).toHaveLength(3);
+    });
+
+    test('handles empty content', () => {
+        const result = transformFile('', 'index.md');
+        expect(result).toBe('');
+    });
+
+    test('handles content with only code blocks', () => {
+        const content = `\`\`\`
+code only
+\`\`\``;
+
+        const result = transformFile(content, 'index.md');
+        expect(result).toBe(content);
+    });
+});

package/scripts/wiki/__tests__/transform.test.js.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2b3c4d5e6f7890abcd1234567890abcd
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/wiki/__tests__.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1a2b3c4d5e6f7890abcd1234567890ab
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/scripts/wiki/generate-wiki-sidebar.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * Generate _Sidebar.md for GitHub Wiki from wiki page structure.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NAV_STRUCTURE = [
+    { title: 'Home', page: 'Home' },
+    { title: 'Getting Started', children: [
+        { title: 'Overview', page: 'Getting-Started-Overview' },
+        { title: 'Getting Started Guide', page: 'Getting-Started-Getting-Started' },
+        { title: 'Installation', page: 'Getting-Started-Install' },
+        { title: 'Quick Start', page: 'Getting-Started-Quick-Start' },
+        { title: 'Visual Guide', page: 'Getting-Started-Visual-Guide' }
+    ]},
+    { title: 'Concepts', children: [
+        { title: 'Message Types', page: 'Concepts-Message-Types' },
+        { title: 'Listening Patterns', page: 'Concepts-Listening-Patterns' },
+        { title: 'Targeting & Context', page: 'Concepts-Targeting-And-Context' },
+        { title: 'Interceptors', page: 'Concepts-Interceptors-And-Ordering' }
+    ]},
+    { title: 'Guides', children: [
+        { title: 'Patterns', page: 'Guides-Patterns' },
+        { title: 'Unity Integration', page: 'Guides-Unity-Integration' },
+        { title: 'Testing', page: 'Guides-Testing' },
+        { title: 'Diagnostics', page: 'Guides-Diagnostics' },
+        { title: 'Advanced', page: 'Guides-Advanced' },
+        { title: 'Migration', page: 'Guides-Migration-Guide' }
+    ]},
+    { title: 'Architecture', children: [
+        { title: 'Design', page: 'Architecture-Design-And-Architecture' },
+        { title: 'Comparisons', page: 'Architecture-Comparisons' },
+        { title: 'Performance', page: 'Architecture-Performance' }
+    ]},
+    { title: 'Advanced', children: [
+        { title: 'Emit Shorthands', page: 'Advanced-Emit-Shorthands' },
+        { title: 'Message Bus Providers', page: 'Advanced-Message-Bus-Providers' },
+        { title: 'Runtime Config', page: 'Advanced-Runtime-Configuration' },
+        { title: 'String Messages', page: 'Advanced-String-Messages' }
+    ]},
+    { title: 'Integrations', children: [
+        { title: 'VContainer', page: 'Integrations-Vcontainer' },
+        { title: 'Zenject', page: 'Integrations-Zenject' },
+        { title: 'Reflex', page: 'Integrations-Reflex' }
+    ]},
+    { title: 'Examples', children: [
+        { title: 'End-to-End', page: 'Examples-End-To-End' },
+        { title: 'Scene Transitions', page: 'Examples-End-To-End-Scene-Transitions' }
+    ]},
+    { title: 'Reference', children: [
+        { title: 'API Reference', page: 'Reference-Reference' },
+        { title: 'Quick Reference', page: 'Reference-Quick-Reference' },
+        { title: 'Helpers', page: 'Reference-Helpers' },
+        { title: 'FAQ', page: 'Reference-Faq' },
+        { title: 'Glossary', page: 'Reference-Glossary' },
+        { title: 'Troubleshooting', page: 'Reference-Troubleshooting' },
+        { title: 'Compatibility', page: 'Reference-Compatibility' }
+    ]}
+];
+
+function pageExists(wikiDir, pageName) {
+    return fs.existsSync(path.join(wikiDir, `${pageName}.md`));
+}
+
+function generateSidebar(wikiDir) {
+    const lines = ['# DxMessaging Wiki', ''];
+
+    for (const item of NAV_STRUCTURE) {
+        if (item.children) {
+            lines.push(`### ${item.title}`);
+            for (const child of item.children) {
+                if (pageExists(wikiDir, child.page)) {
+                    lines.push(`- [[${child.page}|${child.title}]]`);
+                } else {
+                    console.warn(`Missing page: ${child.page}.md - marked as "coming soon"`);
+                    lines.push(`- ${child.title} *(coming soon)*`);
+                }
+            }
+            lines.push('');
+        } else {
+            if (pageExists(wikiDir, item.page)) {
+                lines.push(`- [[${item.page}|${item.title}]]`);
+            }
+        }
+    }
+
+    lines.push('---');
+    lines.push('');
+    lines.push('**Links**');
+    lines.push('- [📦 GitHub](https://github.com/wallstop/DxMessaging)');
+    lines.push('- [📖 Documentation](https://wallstop.github.io/DxMessaging/)');
+
+    return lines.join('\n');
+}
+
+// Main
+function main() {
+    const args = process.argv.slice(2);
+    if (args.length < 1) {
+        console.error('Usage: node generate-wiki-sidebar.js <wiki-dir>');
+        process.exit(1);
+    }
+
+    const wikiDir = path.resolve(args[0]);
+    const sidebar = generateSidebar(wikiDir);
+    const sidebarPath = path.join(wikiDir, '_Sidebar.md');
+    fs.writeFileSync(sidebarPath, sidebar);
+    console.log('Generated _Sidebar.md');
+}
+
+// Only run main when executed directly (not when required as a module)
+if (require.main === module) {
+    try {
+        main();
+    } catch (error) {
+        console.error('Error generating wiki sidebar:', error.message);
+        process.exit(1);
+    }
+}

package/{Docs/EmitShorthands.md.meta → scripts/wiki/generate-wiki-sidebar.js.meta}

@@ -1,8 +1,14 @@
 fileFormatVersion: 2
-guid: 4a1e8b2c3d4f5a6789b0c1d2e3f40516
-TextScriptImporter:
+
+guid: 0b5a7c4d3e6f8901cdef0123456703
+
+DefaultImporter:
+
   externalObjects: {}
+
   userData: 
+
   assetBundleName: 
+
   assetBundleVariant: