@xyd-js/content 0.1.0-xyd.4 → 0.1.0-xyd.55

package/{src/vite-plugins → packages/vite}/index.ts

@@ -1,15 +1,20 @@
 import type {Plugin} from 'rollup';
 import mdx from '@mdx-js/rollup';
 
-import {RemarkMdxTocOptions} from "@/mdx/toc";
-import {mdxOptions} from "@/mdx/options";
+import {Settings} from "@xyd-js/core";
+
+import {RemarkMdxTocOptions, markdownPlugins} from "../md";
 
 export interface VitePluginInterface {
     toc: RemarkMdxTocOptions
+    settings: Settings
 }
 
 export function vitePlugins(options: VitePluginInterface): Plugin[] {
     return [
-        mdx(mdxOptions(options.toc)),
+        mdx(markdownPlugins(
+            options.toc,
+            options.settings
+        )),
     ];
 }

package/src/fs.ts

@@ -0,0 +1,58 @@
+import fs from "fs/promises"
+
+import { VFile } from "vfile"
+import { PluggableList } from "unified";
+import { compile as mdxCompile } from "@mdx-js/mdx";
+
+import { Settings } from "@xyd-js/core"
+
+export {
+    pageFrontMatters,
+    filterNavigationByLevels
+} from "./navigation"
+
+export type { VarCode } from "./types"
+
+export class ContentFS {
+    constructor(
+        private readonly settings: Settings,
+        private readonly remarkPlugins: PluggableList,
+        private readonly rehypePlugins: PluggableList,
+    ) { }
+
+    public async compile(filePath: string): Promise<string> {
+        await fs.access(filePath)
+
+        const content = await fs.readFile(filePath, "utf-8");
+
+        return await this.compileContent(content, filePath)
+    }
+
+
+    public async compileContent(content: string, filePath?: string): Promise<string> {
+        const vfile = new VFile({
+            path: filePath,
+            value: content,
+            contents: content
+        });
+
+        const compiled = await mdxCompile(vfile, {
+            remarkPlugins: this.remarkPlugins,
+            rehypePlugins: this.rehypePlugins,
+            recmaPlugins: [],
+            outputFormat: 'function-body',
+            development: false,
+            jsx: false
+        });
+
+        return String(compiled)
+    }
+
+    public async readRaw(filePath: string) {
+        await fs.access(filePath)
+
+        const content = await fs.readFile(filePath, "utf-8");
+
+        return content
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { ContentFS } from "./fs"
+
+export {
+    pageFrontMatters,
+    filterNavigationByLevels
+} from "./navigation"
+
+export type { VarCode } from "./types"

package/src/{navigation/index.ts → navigation.ts}

@@ -1,31 +1,33 @@
-import {promises as fs} from 'fs';
-import fs2, {open} from 'fs';
+import { promises as fs } from 'fs';
 import path from 'path';
 
 import React from "react";
 import remarkFrontmatter from "remark-frontmatter";
 import remarkMdxFrontmatter from "remark-mdx-frontmatter";
-import matter from 'gray-matter';
-import {VFile} from "vfile";
-import {compile as mdxCompile} from "@mdx-js/mdx";
+import { VFile } from "vfile";
+import { compile as mdxCompile } from "@mdx-js/mdx";
 
-import {FrontMatter, Sidebar, PageFrontMatter, Header} from "@xyd-js/core";
+import { Metadata, Sidebar, MetadataMap, Header, PageURL, VirtualPage } from "@xyd-js/core";
 
 // TODO: better algorithm + data structures - since it's on build time it's not a big deal nevertheless it should be changed in the future
 
 // pageFrontMatters gets frontmatters for given navigation
-export async function pageFrontMatters(navigation: Sidebar[]): Promise<PageFrontMatter> {
-    const frontmatters: PageFrontMatter = {}
+export async function pageFrontMatters(navigation: Sidebar[], pagePathMapping: { [key: string]: string }): Promise<MetadataMap> {
+    const frontmatters: MetadataMap = {}
 
     const promises: Promise<any>[] = []
 
-    function mapPages(page: string | Sidebar) {
+    function mapPages(page: PageURL) {
         if (typeof page !== "string") {
-            page.pages?.forEach(mapPages)
+            if ("virtual" in page) {
+                promises.push(job(page, frontmatters, pagePathMapping))
+            } else if ("pages" in page) {
+                page.pages?.forEach(mapPages)
+            }
             return
         }
 
-        promises.push(job(page, frontmatters))
+        promises.push(job(page, frontmatters, pagePathMapping))
     }
 
     navigation.map(async (nav: Sidebar) => {
@@ -43,7 +45,7 @@ export function filterNavigationByLevels(
     slug: string
 ) {
     const topLevelTabMatcher = headers?.reduce((acc: any, header) => {
-        const tabLevel = header?.url?.split("/")?.length
+        const tabLevel = header?.page?.split("/")?.length
 
         if (!tabLevel) {
             return {
@@ -54,13 +56,13 @@ export function filterNavigationByLevels(
         if (!acc[tabLevel]) {
             return {
                 ...acc,
-                [tabLevel]: new Set().add(header?.url)
+                [tabLevel]: new Set().add(header?.page)
             }
         }
 
         return {
             ...acc,
-            [tabLevel]: acc[tabLevel].add(header?.url)
+            [tabLevel]: acc[tabLevel].add(header?.page)
         }
     }, {}) as { [level: number]: Set<string> }
 
@@ -74,11 +76,20 @@ export function filterNavigationByLevels(
             const level = parseInt(levelStr)
             const findThisSlug = slug.split("/").filter(s => !!s).slice(0, level).join("/")
 
-            function findMatchedPage(page: string | Sidebar) {
+            function findMatchedPage(page: PageURL) {
                 if (typeof page !== "string") {
-                    page.pages?.forEach(findMatchedPage)
+                    if ("virtual" in page && page.virtual) {
+                        return matchPage(page.virtual)
+                    } else if ("pages" in page) {
+                        page.pages?.forEach(findMatchedPage)
+                    }
                     return
                 }
+
+                return matchPage(page)
+            }
+
+            function matchPage(page: string) {
                 const findThisPage = page.split("/").filter(p => !!p).slice(0, level).join("/")
 
                 const set = topLevelTabMatcher[level]
@@ -96,27 +107,6 @@ export function filterNavigationByLevels(
     }
 }
 
-async function getFrontmatter(filePath: string, chunkSize = 1024 * 5) { // 5 KB chunk
-    return new Promise((resolve, reject) => {
-        open(filePath, 'r', (err, fd) => {
-            if (err) return reject(err);
-
-            const buffer = Buffer.alloc(chunkSize);
-            fs2.read(fd, buffer, 0, chunkSize, 0, (err, bytesRead) => {
-                if (err) return reject(err);
-
-                const uint8Array = new Uint8Array(buffer.buffer, buffer.byteOffset, bytesRead);
-                const content = new TextDecoder('utf-8').decode(uint8Array);
-                const {data: frontmatter} = matter(content); // extract frontmatter
-                resolve(frontmatter);
-
-                fs2.close(fd, () => {
-                });
-            });
-        });
-    });
-}
-
 function mdxExport(code: string) {
     const scope = {
         Fragment: React.Fragment,
@@ -128,7 +118,7 @@ function mdxExport(code: string) {
     return fn(scope)
 }
 
-async function getFrontmatterV2(filePath: string): Promise<FrontMatter> {
+async function getFrontmatter(filePath: string): Promise<Metadata> {
     const body = await fs.readFile(filePath, "utf-8");
 
     const vfile = new VFile({
@@ -155,34 +145,40 @@ async function getFrontmatterV2(filePath: string): Promise<FrontMatter> {
         frontmatter
     } = mdxExport(code)
 
-    const matter: FrontMatter = frontmatter
+    const matter: Metadata = frontmatter
+
+    if (!matter) {
+        throw new Error(`Frontmatter not found in ${filePath}`)
+    }
 
+    let title = ""
+    if (typeof matter.title === "string") {
+        title = matter.title
+    }
     if (reactFrontmatter) {
-        if (typeof reactFrontmatter?.title === "function") {
-            matter.title = {
-                code: reactFrontmatter.title.toString()
-            }
-        }
+        console.error("currently react frontmatter is not supported")
     }
 
     return matter
 }
 
-async function job(page: string, frontmatters: PageFrontMatter) {
-    // TODO: it can be cwd because on build time it has entire path?
-    let filePath = path.join(process.cwd(), `${page}.mdx`) // TODO: support md toos
-    try {
-        await fs.access(filePath)
-    } catch (e) {
-        try {
-            const mdPath = filePath.replace(".mdx", ".md")
-            await fs.access(mdPath)
-            filePath = mdPath
-        } catch (e) {
-        }
+// TODO: indices map to not do like this - search for mdx if not then md
+async function job(page: string | VirtualPage, frontmatters: MetadataMap, pagePathMapping: { [key: string]: string }) {
+    let pageName = ""
+    if (typeof page === "string") {
+        pageName = page
+    } else if (page.page) {
+        pageName = page.page
+    }
+
+    if (!pageName || !pagePathMapping[pageName]) {
+        console.log(`⚠️ "${pageName}" is defined in the docs.json navigation but the file does not exist.`)
+        return
     }
 
-    const matter = await getFrontmatterV2(filePath)
+    const filePath = path.join(process.cwd(), pagePathMapping[pageName])
+    
+    const matter = await getFrontmatter(filePath)
 
-    frontmatters[page] = matter
+    frontmatters[pageName] = matter
 }

package/src/types.ts

@@ -0,0 +1,8 @@
+import { HighlightedCode } from "codehike/code"
+
+export type VarCode = [
+    [
+        string,
+        ...(HighlightedCode)[]
+    ] | HighlightedCode
+]

package/tsconfig.json

@@ -2,10 +2,24 @@
   "compilerOptions": {
     "baseUrl": ".",
     "paths": {
-      "@/mdx/*": ["src/mdx/*"],
-      "@/navigation/*": ["src/navigation/*"],
-      "@/utils/*": ["src/utils/*"],
-      "@/vite-plugins/*": ["src/vite-plugins/*"]
+      "@/mdx/*": [
+        "src/mdx/*"
+      ],
+      "@/navigation/*": [
+        "src/navigation/*"
+      ],
+      "@/utils/*": [
+        "src/utils/*"
+      ],
+      "@/vite-plugins/*": [
+        "src/vite-plugins/*"
+      ],
+      "@xyd-js/core": [
+        "../xyd-core"
+      ],
+      "@xyd-js/context": [
+        "../xyd-context/src/index.ts"
+      ]
     },
     "target": "ES2020",
     "module": "ESNext",
@@ -15,12 +29,21 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "outDir": "./dist",
-    "types": ["node", "estree", "vite"],
+    "types": [
+      "node",
+      "estree",
+      "vite"
+    ],
     "declaration": true,
     "declarationMap": true,
     "incremental": true,
-    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo"
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo",
   },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
+  "include": [
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
 }

package/tsup.config.ts

@@ -1,21 +1,23 @@
-import { defineConfig, Options } from 'tsup';
+import {defineConfig, Options} from 'tsup';
 
 const config: Options = {
     entry: {
-        index: 'index.ts',
-        navigation: 'navigation.ts',
+        index: 'src/index.ts',
+        vite: 'packages/vite/index.ts',
+        md: 'packages/md/index.ts',
     },
     dts: {
         entry: {
-            index: 'index.ts',
-            navigation: 'navigation.ts',
+            index: 'src/index.ts',
+            vite: 'packages/vite/index.ts',
+            md: 'packages/md/index.ts'
         },
         resolve: true, // Resolve external types
     },
     format: ['esm'], // Output both ESM and CJS formats
     target: 'node16', // Ensure compatibility with Node.js 16
     splitting: false, // Disable code splitting
-    sourcemap: false, // Generate source maps
+    sourcemap: true, // Generate source maps
     clean: true, // Clean the output directory before each build
     // esbuildOptions: (options) => {
     //     options.platform = 'node'; // Ensure the platform is set to Node.js

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import {defineConfig} from 'vitest/config'
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: [
+            'src/**/*.test.ts',
+            'packages/**/*.test.ts',
+            '**/__tests__/**/*.test.ts'
+        ],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+        },
+    },
+}) 

package/dist/navigation.d.ts

@@ -1,6 +0,0 @@
-import { Sidebar, PageFrontMatter, Header } from '@xyd-js/core';
-
-declare function pageFrontMatters(navigation: Sidebar[]): Promise<PageFrontMatter>;
-declare function filterNavigationByLevels(headers: Header[], slug: string): (nav: Sidebar) => boolean;
-
-export { filterNavigationByLevels, pageFrontMatters };