@xyd-js/uniform 0.1.0-xyd.4 → 0.1.0-xyd.56

package/src/markdown/utils.ts

@@ -1,3 +1,4 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
 import {u} from "unist-builder";
 
 import {
@@ -41,13 +42,12 @@ export function heading(
     let uDesc = [
         u(
             'heading',
-            {depth: START_DEPTH_LEVEL},
+            {depth: uTitle.depth + 1},
             [u('text', `!description`),]
         ),
         u('paragraph', [u('text', description)])
     ]
 
-
     let uRefCategory
     if (refCategory) {
         uRefCategory = u(
@@ -79,12 +79,24 @@ export function heading(
 
 
         for (const [key, value] of Object.entries(refContext)) {
-            uContext.push(u(
-                    'heading',
-                    {depth: uContext[0].depth + 1},
-                    [u('text', `!${key} ${value}`)]
-                )
-            )
+            if (typeof value === "object") {
+                // TODO: support ```<lang> ??
+                if (value.code) {
+                    uContext.push(
+                        u('heading', {depth: uContext[0].depth + 1}, [u('text', `!${key}`)])
+                    );
+
+                    uContext.push(
+                        u('code', {lang: value.lang}, value.code)
+                    );
+
+                    continue;
+                }
+            }
+
+            uContext.push(
+                u('heading', {depth: uContext[0].depth + 1}, [u('text', `!${key} ${value.toString()}`)])
+            );
         }
     }
 
@@ -191,6 +203,7 @@ export function definitions(definitions: Definition[]) {
                     name: prop.name,
                     type: prop.type,
                     description: prop.description,
+                    context: prop.context,
                     properties: prop.properties  // TODO: fix ts
                 },
                 md,
@@ -213,13 +226,35 @@ export function properties(
     const uPropTitle = u('heading', {depth}, [u('text', propTitle)]);
     const uPropName = u('paragraph', {depth}, [u('text', `!name ${paramName}`)]);
     const uPropType = u('paragraph', {depth}, [u('text', `!type ${props.type}`)]);
-    const uPropDesc = u('paragraph', {depth}, [u('text', props.description || '')]);
+    const markdownAst = fromMarkdown(props.description || '');
+    const uPropDesc = u("paragraph", { depth }, markdownAst.children);
+    const uContext = []
+
+    if (props.context && Object.keys(props.context)) {
+        uContext.push(u(
+            'heading',
+            {depth: depth + 1},
+            [
+                u('text', `!context`),
+            ]
+        ))
+
+        for (const [key, value] of Object.entries(props.context)) {
+            uContext.push(u(
+                    'heading',
+                    {depth: uContext[0].depth + 1},
+                    [u('text', `!${key} ${value}`)]
+                )
+            )
+        }
+    }
 
     output.push(
         uPropTitle,
         uPropName,
         uPropType,
-        uPropDesc
+        uPropDesc,
+        ...uContext
     );
 
     if (props.properties) {

package/src/plugins/__tests__/pluginJsonView.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import { pluginJsonView } from '../pluginJsonView';
+import type { Reference } from '../../types';
+import uniform from '../../index'
+
+describe('pluginJsonView', () => {
+    it('should handle properties without examples', () => {
+        const plugin = pluginJsonView();
+
+        const inputs: Reference[] = [
+            {
+                title: 'Test title',
+                description: 'Test description',
+                canonical: 'test-canonical',
+                examples: {
+                    groups: []
+                },
+                "definitions": [
+                    {
+                        "title": "Properties",
+                        "properties": [
+                            {
+                                "name": "charset",
+                                "type": "string",
+                                "description": "Character encoding for the document\n",
+                                "examples": [
+                                    "\"UTF-8\""
+                                ]
+                            },
+                            {
+                                "name": "robots",
+                                "type": "string",
+                                "description": "Standard meta tag for controlling search engine crawling and indexing\n",
+                                "examples": [
+                                    "\"index, follow\"",
+                                    "\"noindex, nofollow\""
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            },
+            {
+                title: 'Test title',
+                description: 'Test description',
+                canonical: 'test-canonical',
+                examples: {
+                    groups: []
+                },
+                "definitions": [
+                    {
+                        "title": "Properties",
+                        "properties": [
+                            {
+                                "name": "charset",
+                                "type": "string",
+                                "description": "Character encoding for the document\n",
+                                "examples": [
+                                    "UTF-8"
+                                ]
+                            },
+                            {
+                                "name": "robots",
+                                "type": "string",
+                                "description": "Standard meta tag for controlling search engine crawling and indexing\n",
+                                "examples": [
+                                    "index, follow",
+                                    "noindex, nofollow"
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            },
+            {
+                title: 'Test title',
+                description: 'Test description',
+                canonical: 'test-canonical',
+                examples: {
+                    groups: []
+                },
+                "definitions": [
+                    {
+                        "title": "Properties",
+                        "properties": [
+                            {
+                                "name": "robots",
+                                "type": "string",
+                                "description": "Standard meta tag for controlling search engine crawling and indexing\n",
+                                "examples": [
+                                    "index, follow",
+                                    "noindex, nofollow"
+                                ]
+                            },
+                            {
+                                "name": "charset",
+                                "type": "string",
+                                "description": "Character encoding for the document\n",
+                                "examples": [
+                                    "UTF-8"
+                                ]
+                            },
+                        ]
+                    }
+                ]
+            }
+        ];
+
+        const outputs: string[] = [
+            '{\n' +
+            '    "charset": "UTF-8",\n' +
+            '    "robots": "index, follow" // or "noindex, nofollow"\n' +
+            '}',
+
+            '{\n' +
+            '    "charset": "UTF-8",\n' +
+            '    "robots": "index, follow" // or "noindex, nofollow"\n' +
+            '}',
+
+            '{\n' +
+            '    "robots": "index, follow", // or "noindex, nofollow"\n' +
+            '    "charset": "UTF-8"\n' +
+            '}',
+        ]
+        const result = uniform(inputs, {
+            plugins: [plugin]
+        });
+
+        expect(result.out.jsonViews).toStrictEqual(outputs);
+    });
+}); 

package/src/plugins/index.ts

@@ -0,0 +1,2 @@
+export { pluginJsonView } from "./pluginJsonView"
+export { pluginNavigation } from "./pluginNavigation"

package/src/plugins/pluginJsonView.ts

@@ -0,0 +1,54 @@
+import type { UniformPluginArgs, UniformPlugin } from "../index";
+import { Reference } from "../types";
+
+export interface pluginJsonViewOptions {
+}
+
+type pluginJsonViewOutput = {
+    jsonViews: string;
+}
+
+export function pluginJsonView(
+    options?: pluginJsonViewOptions
+): UniformPlugin<pluginJsonViewOutput> {
+
+    return function pluginJsonViewInner({
+        defer,
+    }: UniformPluginArgs) {
+        const jsonViews: string[] = [];
+
+        defer(() => ({
+            jsonViews
+        }))
+
+        return (ref: Reference) => {
+            // Build the output string manually to ensure exact format
+            const lines: string[] = [];
+            lines.push('{');
+            
+            ref.definitions.forEach(def => {
+                def.properties.forEach((prop, index) => {
+                    // Remove any quotes and trailing characters from the value
+                    const value = (prop.examples?.[0] || '').replace(/^"|"$|[^a-zA-Z0-9\s\-_.,:/@#=;+()]/g, '');
+                    const comment = prop.examples && prop.examples.length > 1 
+                        ? ` // or "${(prop.examples as string[])[1].replace(/^"|"$|[^a-zA-Z0-9\s\-_.,:/@#=;+()]/g, '')}"`
+                        : '';
+                    const isLast = index === def.properties.length - 1;
+                    // Add comma after the value but before the comment
+                    lines.push(`    "${prop.name}": "${value}"${isLast ? '' : ','}${comment}`);
+                });
+            });
+            
+            lines.push('}');
+            
+            jsonViews.push(lines.join('\n'));
+        }
+    }
+}
+
+// example usage:
+// const response = uniform([/* references */], {
+//     plugins: [pluginJsonView({
+//         
+//     })],
+// });

package/src/plugins/pluginNavigation.ts

@@ -0,0 +1,135 @@
+import path from 'node:path';
+
+import type { Sidebar, Metadata, MetadataMap, Settings, PageURL } from "@xyd-js/core";
+
+import type { UniformPluginArgs, UniformPlugin } from "../index";
+import { CodeBlockTab, Example, ExampleGroup, Reference } from "../types";
+
+const DEFAULT_VIRTUAL_FOLDER = ".xyd/.cache/.content" // TODO: share this + .xyd/.build/.content for build
+
+const DEFAULT_GROUP_NAME = "API Reference" // TODO: configurable
+
+type GroupMap = {
+    [key: string]: {
+        __groups: GroupMap
+        pages: Set<string>
+    }
+}
+
+export interface pluginNavigationOptions {
+    urlPrefix: string
+    defaultGroup?: string
+}
+
+type pluginNavigationOutput = {
+    pageFrontMatter: MetadataMap;
+    sidebar: Sidebar[];
+}
+
+export function pluginNavigation(
+    settings: Settings,
+    options: pluginNavigationOptions
+): UniformPlugin<pluginNavigationOutput> {
+    if (!options.urlPrefix) {
+        throw new Error("urlPrefix is required")
+    }
+
+    return function pluginNavigationInner({
+        defer,
+    }: UniformPluginArgs) {
+        const pageFrontMatter: MetadataMap = {}
+        const groupMaps: GroupMap = {}
+
+        defer(() => ({
+            pageFrontMatter,
+            sidebar: convertGroupMapsToSidebar(settings, groupMaps) as Sidebar[]
+        }))
+
+        return (ref: Reference) => {
+            const dataCtx = ref.context
+            const pagePath = path.join(options.urlPrefix, ref.canonical)
+
+            let group = dataCtx?.group || []
+            let title = ref.title
+
+            if (pageFrontMatter[pagePath]) {
+                console.error("(pluginNavigation): pageFrontMatter[pagePath] already exists", pagePath)
+            }
+
+            if (!group) {
+                group = [options.defaultGroup || DEFAULT_GROUP_NAME]
+            }
+
+            pageFrontMatter[pagePath] = {
+                title,
+            }
+
+            if (typeof group === "string") {
+                // TODO: seek nested group (it's not always from 0)
+                throw new Error("group as string is not supported yet")
+            }
+
+            group.reduce((groups: GroupMap, groupName: string, i: number) => {
+                if (!groups[groupName]) {
+                    groups[groupName] = {
+                        __groups: {},
+                        pages: new Set()
+                    }
+                }
+
+                if (i === group.length - 1) {
+                    groups[groupName].pages.add(pagePath)
+                }
+
+                return groups[groupName].__groups
+            }, groupMaps)
+        }
+    }
+}
+
+function convertGroupMapsToSidebar(settings: Settings, groupMaps: GroupMap): Sidebar[] {
+    const nav: Sidebar[] = []
+
+    Object.keys(groupMaps).map((groupName) => {
+        const current = groupMaps[groupName]
+
+        const pages: PageURL[] = []
+
+        current.pages.forEach((page: string) => {
+            if (settings?.engine?.uniform?.store) {
+                pages.push(page)
+                return
+            }
+            pages.push({
+                virtual: path.join(DEFAULT_VIRTUAL_FOLDER, page),
+                page: page,
+            })
+        })
+
+        if (Object.keys(current.__groups).length) {
+            const subNav: Sidebar = {
+                group: groupName,
+                pages: convertGroupMapsToSidebar(settings, current.__groups)
+            }
+
+            nav.push(subNav)
+
+            return
+        }
+
+        nav.push({
+            group: groupName,
+            pages,
+        })
+    })
+
+    return nav
+}
+
+// TODO: in the future xyd settings must be removed cuz uniform will be part of opendocs
+// example usage:
+// const response = uniform([/* references */], {
+//     plugins: [pluginNavigation({}, {
+//         urlPrefix: "/docs"
+//     })],
+// });