@xyd-js/uniform 0.1.0-build.172

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@xyd-js/uniform",
+  "version": "0.1.0-build.172",
+  "description": "",
+  "main": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./dist/index.js",
+    "./markdown": "./dist/markdown.js",
+    "./content": "./dist/content.js"
+  },
+  "dependencies": {
+    "codehike": "^1.0.3",
+    "mdast-util-from-markdown": "^2.0.2",
+    "remark": "^15.0.1",
+    "remark-stringify": "^11.0.0",
+    "unist-builder": "^4.0.0",
+    "unist-util-visit": "^5.0.0",
+    "@xyd-js/core": "0.1.0-build.170"
+  },
+  "peerDependencies": {
+    "@mdx-js/mdx": "^3.1.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^1.3.1",
+    "@types/node": "^22.10.5",
+    "rimraf": "^3.0.2",
+    "tsup": "^8.3.0",
+    "typescript": "^4.5.5",
+    "vitest": "^1.3.1"
+  },
+  "scripts": {
+    "clean": "rimraf build",
+    "prebuild": "pnpm clean",
+    "build": "tsup",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/src/content/index.ts

@@ -0,0 +1,124 @@
+import path from "path";
+import {promises as fs} from "fs";
+
+import React from "react";
+import {parse} from "codehike";
+import {visit} from "unist-util-visit";
+import {recmaCodeHike, remarkCodeHike} from "codehike/mdx";
+import {compile as mdxCompile} from "@mdx-js/mdx";
+
+const codeHikeOptions = {
+    lineNumbers: true,
+    showCopyButton: true,
+    autoImport: true,
+    components: {code: "Code"},
+    // syntaxHighlighting: { // TODO: !!! FROM SETTINGS !!! wait for rr7 rsc ??
+    //     theme: "github-dark",
+    // },
+};
+//
+// // since unist does not support heading level > 6, we need to normalize them
+function normalizeCustomHeadings() {
+    return (tree: any) => {
+        visit(tree, 'paragraph', (node, index, parent) => {
+            const match = node.children[0] && node.children[0].value.match(/^(#+)\s+(.*)/);
+            if (match) {
+                const level = match[1].length;
+                const text = match[2];
+                if (level > 6) {
+                    // Create a new heading node with depth 6
+                    const headingNode = {
+                        type: 'heading',
+                        depth: level,
+                        children: [{type: 'text', value: text}]
+                    };
+                    // Replace the paragraph node with the new heading node
+                    //@ts-ignore
+                    parent.children[index] = headingNode;
+                }
+            }
+        });
+    };
+}
+
+//
+async function compile(content: string): Promise<string> {
+    const compiled = await mdxCompile(content, {
+        remarkPlugins: [normalizeCustomHeadings, [remarkCodeHike, codeHikeOptions]],
+        recmaPlugins: [
+            [recmaCodeHike, codeHikeOptions]
+        ],
+        outputFormat: 'function-body',
+        development: false,
+    });
+
+    return String(compiled)
+}
+
+async function compileBySlug(slug: string) {
+    // TODO: cwd ?
+    const filePath = path.join(process.cwd(), `${slug}.md`)
+
+    try {
+        await fs.access(filePath)
+    } catch (e) {
+        console.error(e)
+        return ""
+    }
+
+    const content = await fs.readFile(filePath, "utf-8");
+
+    return await compile(content)
+}
+
+function getMDXComponent(code: string) {
+    const mdxExport = getMDXExport(code)
+    return mdxExport.default
+}
+
+function getMDXExport(code: string) {
+    const scope = {
+        Fragment: React.Fragment,
+        jsxs: React.createElement,
+        jsx: React.createElement,
+        jsxDEV: React.createElement,
+    }
+    const fn = new Function(...Object.keys(scope), code)
+    return fn(scope)
+}
+
+//
+// function MDXContent(code: string) {
+//     return React.useMemo(
+//         () => code ? getMDXComponent(code) : null,
+//         [code]
+//     )
+// }
+
+// TODO: mod ts
+async function lazyReferences(mod: any) {
+    const references: any[] = []
+
+    if (Array.isArray(mod.default)) {
+        for (const chunk of mod.default) {
+            try {
+                const code = await compile(chunk) // TODO: do we need real path?
+                const Content = getMDXComponent(code)
+                const content = Content ? parse(Content) : null
+
+                references.push(...content.references as [])
+            } catch (e) {
+                console.error(e)
+            }
+        }
+    } else {
+        console.warn(`mod.default is not an array, current type is: ${typeof mod.default}`)
+    }
+
+    return references
+}
+
+export {
+    compileBySlug,
+    lazyReferences
+}

package/src/index.ts

@@ -0,0 +1,105 @@
+// Define the new PluginV type with a callback function that returns another function
+import {Reference} from "./types";
+
+export * from "./types";
+
+// Define the new PluginV type with a callback function that returns another function
+export type UniformPluginArgs = {
+    references: Reference[] | Reference,
+    defer: (defer: () => any) => void;
+
+    // TODO: maybe in the future
+    // visit: (selector: string | "[method] [path]", callback: (...args: any[]) => void) => void;
+}
+
+
+export type UniformPluginRestArgs = {
+    index: number;
+}
+export type UniformPlugin<T> = (args: UniformPluginArgs) => (ref: Reference, restArgs: UniformPluginRestArgs) => void;
+
+// Utility type to infer if a type is an array and avoid wrapping it into an array twice
+type NormalizeArray<T> = T extends Array<infer U> ? U[] : T;
+
+// Infer the return type of the plugin callback properly and normalize array types
+type PluginResult<T extends UniformPlugin<any>> = T extends UniformPlugin<infer R> ? R : never;
+
+// Merge all plugin return types into a single object and normalize arrays
+type MergePluginResults<T extends UniformPlugin<any>[]> = {
+    [K in keyof UnionToIntersection<PluginResult<T[number]>>]: NormalizeArray<UnionToIntersection<PluginResult<T[number]>>[K]>
+};
+
+// Utility type to handle intersection to an object type
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+// Implement the uniform function
+export default function uniform<T extends UniformPlugin<any>[]>(
+    references: Reference[],
+    config: { plugins: T }
+) {
+    // Infer the merged result type from all plugins
+    type ResultType = MergePluginResults<T>;
+
+    // Initialize the response with a type-safe out object
+    const response: {
+        references: Reference[]
+        out: { [K in keyof ResultType]: ResultType[K] }
+    } = {
+        references,
+        out: {} as { [K in keyof ResultType]: ResultType[K] }
+    };
+
+    config.plugins.forEach((plugin) => {
+        let defer: any = undefined; // fix any
+
+        const call = plugin({
+            references: references,
+            defer: (cb) => {
+                if (typeof cb === "function") {
+                    defer = cb
+                }
+            },
+            // visit: (pattern, callback) => {
+            // }
+        })
+
+        references.map((ref, i) => {
+            call(ref, {
+                index: i,
+            })
+        });
+
+        if (typeof defer === "function") {
+            const resp = defer()
+            if (typeof resp !== "object") {
+                throw new Error(`Invalid callback return type: ${typeof resp}`)
+            }
+
+            response.out = {
+                ...response.out,
+                ...resp
+            }
+        }
+    })
+
+    return response;
+}
+
+// Example usage
+// const examplePlugin: UniformPlugin<{ value: boolean }> = (cb) => {
+//     return (ref: Reference) => {
+//     };
+// };
+// function examplePlugin(defer: (defer: () => { value: boolean }) => void) {
+//     defer(() => ({
+//         value: true,
+//     }));
+//
+//     return (ref: Reference) => {
+//
+//     };
+// }
+// const response = uniform([/* references */], {
+//     plugins: [examplePlugin],
+// });
+// response.out

package/src/markdown/index.ts

@@ -0,0 +1,67 @@
+import {remark} from "remark";
+import remarkStringify from "remark-stringify";
+
+import {Reference} from "../types";
+
+import {definitions, examples, heading, root} from "./utils";
+
+// TODO: any
+export function compile(ast: any) {
+    return remark()
+        // .use(unlimitedHeadings)
+        .use(remarkStringify, {
+            bullet: '-',
+            fences: true,
+            listItemIndent: 'one',
+            incrementListMarker: false,
+            handlers: {
+                heading(node) {
+                    return `${"#".repeat(node.depth)} ${node.children[0].value}`;
+                },
+            },
+        })
+        .stringify(root(ast));
+}
+
+export function referenceAST(ref: Reference) {
+    const md = []
+
+    const mdHeading = heading(
+        ref.title,
+        ref.canonical,
+        typeof ref.description === "string" ? ref.description : "",
+        ref.category,
+        ref.type,
+        ref.context
+    )
+
+    md.push(
+        mdHeading.title,
+    )
+
+    if (mdHeading?.description?.length) {
+        md.push(...mdHeading.description)
+    }
+
+    md.push(
+        mdHeading.canonical,
+    )
+
+    if (mdHeading.category) {
+        md.push(mdHeading.category)
+    }
+
+    if (mdHeading.type) {
+        md.push(mdHeading.type)
+    }
+
+    if (mdHeading?.context?.length) {
+        md.push(...mdHeading.context)
+    }
+
+    const mdExamples = examples(ref.examples)
+    const mdDefinitions = definitions(ref.definitions)
+    md.push(...mdExamples, ...mdDefinitions)
+
+    return md;
+}

package/src/markdown/utils.ts

@@ -0,0 +1,270 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import {u} from "unist-builder";
+
+import {
+    ExampleRoot,
+    Definition,
+    ReferenceCategory,
+    ReferenceContext,
+    ReferenceType,
+    DefinitionProperty
+} from "../types";
+
+// START_DEPTH_LEVEL is the start depth level for the markdown AST
+// starts from 2 because 1 is reserved for the title
+const START_DEPTH_LEVEL = 2
+
+// TODO: fix any
+export function root(ast: any) {
+    return u('root', ast);
+}
+
+export function heading(
+    title: string,
+    canonical: string,
+    description: string,
+    refCategory?: ReferenceCategory,
+    refType?: ReferenceType,
+    refContext?: ReferenceContext
+) {
+    const uTitle = u(
+        'heading',
+        {depth: START_DEPTH_LEVEL},
+        [u('text', `!!references ${title}`)]
+    )
+
+    const uCanonical = u(
+        'heading',
+        {depth: uTitle.depth + 1},
+        [u('text', `!canonical ${canonical}`)]
+    )
+
+    let uDesc = [
+        u(
+            'heading',
+            {depth: uTitle.depth + 1},
+            [u('text', `!description`),]
+        ),
+        u('paragraph', [u('text', description)])
+    ]
+
+    let uRefCategory
+    if (refCategory) {
+        uRefCategory = u(
+            'heading',
+            {depth: uTitle.depth + 1},
+            [u('text', `!category ${refCategory}`)]
+        )
+    }
+
+    let uRefType
+    if (refType) {
+        uRefType = u(
+            'heading',
+            {depth: uTitle.depth + 1},
+            [u('text', `!type ${refType}`)]
+        )
+    }
+
+    let uContext = []
+
+    if (refContext && Object.keys(refContext)) {
+        uContext.push(u(
+            'heading',
+            {depth: uTitle.depth + 1},
+            [
+                u('text', `!context`),
+            ]
+        ))
+
+
+        for (const [key, value] of Object.entries(refContext)) {
+            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()}`)])
+            );
+        }
+    }
+
+    return {
+        title: uTitle,
+        canonical: uCanonical,
+        description: uDesc,
+        category: uRefCategory || null,
+        type: uRefType || null,
+        context: uContext || null
+    }
+}
+
+export function examples(examples: ExampleRoot) {
+    const md = []
+
+    const uExampleRoot = u(
+        'heading',
+        {depth: START_DEPTH_LEVEL + 1},
+        [u('text', `!examples`)]
+    )
+    md.push(uExampleRoot)
+
+    examples.groups.forEach(group => {
+        const uExampleGroups = u(
+            'heading',
+            {depth: uExampleRoot.depth + 1},
+            [u('text', `!!groups`)]
+        )
+        md.push(uExampleGroups)
+
+        const uGroupDescription = u(
+            'heading',
+            {depth: uExampleGroups.depth + 1},
+            [u('text', `!description ${group.description}`)]
+        )
+        md.push(uGroupDescription)
+
+        group.examples.forEach(example => {
+            const uExamples = u(
+                'heading',
+                {depth: uExampleGroups.depth + 1},
+                [u('text', `!!examples`)]
+            )
+            md.push(uExamples)
+
+            const codeBlock = u(
+                'heading',
+                {depth: uExamples.depth + 1},
+                [u('text', `!codeblock`)]
+            )
+            md.push(codeBlock)
+
+            const codeBlockTitle = u(
+                'heading',
+                {depth: codeBlock.depth + 1},
+                [u('text', `!title ${example.codeblock.title}`)]
+            )
+            md.push(codeBlockTitle)
+
+            const tabs = u(
+                'heading',
+                {depth: codeBlock.depth + 1},
+                [u('text', `!!tabs`)]
+            )
+            md.push(tabs)
+
+            example.codeblock.tabs.forEach(tab => {
+                const code = u('code', {
+                    lang: tab.language,
+                    meta: `!code ${tab.title}`
+                }, tab.code);
+
+                md.push(code)
+            })
+
+        })
+    })
+
+    return md
+}
+
+export function definitions(definitions: Definition[]) {
+    const md: any[] = []
+
+    definitions.forEach(definition => {
+        const uDefinition = u(
+            'heading',
+            {depth: START_DEPTH_LEVEL + 1},
+            [u('text', `!!definitions`)]
+        )
+        md.push(uDefinition)
+
+        md.push(u(
+            'heading',
+            {depth: uDefinition.depth + 1},
+            [u('text', `!title ${definition.title}`)]
+        ))
+
+        definition.properties.forEach(prop => {
+            properties(
+                uDefinition.depth + 1,
+                {
+                    name: prop.name,
+                    type: prop.type,
+                    description: prop.description,
+                    context: prop.context,
+                    properties: prop.properties  // TODO: fix ts
+                },
+                md,
+            )
+        })
+    })
+
+    return md
+}
+
+// TODO: any[]
+export function properties(
+    depth: number,
+    props: DefinitionProperty,
+    output: any[] = []
+) {
+    const paramName = props.name;
+
+    const propTitle = `!!properties ${paramName}`; // TODO: check if `!!properties is enough`
+    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 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,
+        ...uContext
+    );
+
+    if (props.properties) {
+        const deepDepth = depth + 1
+
+        for (const prop of props.properties) {
+            properties(deepDepth, prop, output)
+        }
+    }
+}
+
+
+