@xyd-js/host 0.1.0-xyd.2

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# @xyd-js/host
+
+## 0.1.0-xyd.2
+
+### Patch Changes
+
+- test
+- Updated dependencies
+  - @xyd-js/atlas@0.1.0-xyd.18
+  - @xyd-js/components@0.1.0-xyd.13
+  - @xyd-js/composer@0.1.0-xyd.2
+  - @xyd-js/core@0.1.0-xyd.15
+  - @xyd-js/framework@0.1.0-xyd.34
+  - @xyd-js/plugin-algolia@0.1.0-xyd.2
+  - @xyd-js/plugin-orama@0.1.0-xyd.2
+  - @xyd-js/theme-cosmo@0.1.0-xyd.2
+  - @xyd-js/theme-opener@0.1.0-xyd.2
+  - @xyd-js/theme-picasso@0.1.0-xyd.2
+  - @xyd-js/theme-poetry@0.1.0-xyd.29
+  - @xyd-js/themes@0.1.1-xyd.5
+
+## 0.1.0-xyd.1
+
+### Patch Changes
+
+- update packages
+- Updated dependencies
+  - @xyd-js/atlas@0.1.0-xyd.17
+  - @xyd-js/components@0.1.0-xyd.12
+  - @xyd-js/composer@0.1.0-xyd.1
+  - @xyd-js/core@0.1.0-xyd.14
+  - @xyd-js/framework@0.1.0-xyd.33
+  - @xyd-js/plugin-algolia@0.1.0-xyd.1
+  - @xyd-js/plugin-orama@0.1.0-xyd.1
+  - @xyd-js/theme-cosmo@0.1.0-xyd.1
+  - @xyd-js/theme-opener@0.1.0-xyd.1
+  - @xyd-js/theme-picasso@0.1.0-xyd.1
+  - @xyd-js/theme-poetry@0.1.0-xyd.28
+  - @xyd-js/themes@0.1.1-xyd.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 xyd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/app/debug-null.tsx

@@ -0,0 +1,3 @@
+export default function DebugNull() {
+    return null
+  }

package/app/docPaths.ts

@@ -0,0 +1,65 @@
+import {PageURL, Settings, Sidebar} from "@xyd-js/core";
+
+export function docPaths(navigation: Settings['navigation']) {
+    if (!navigation?.sidebar) return [];
+
+    const paths: string[] = [];
+
+    // Process each sidebar group
+    navigation.sidebar.forEach(sidebarGroup => {
+        if (typeof sidebarGroup === "string") {
+            paths.push(sidebarGroup.startsWith("/") ? sidebarGroup : `/${sidebarGroup}`)
+            return
+        }
+
+        // Add the route of the sidebar group
+        if ('route' in sidebarGroup) {
+            const route = sidebarGroup.route;
+            if (route) {
+                paths.push(`/${route}`);
+            }
+        }
+
+        // Process items in the sidebar group
+        if ("pages" in sidebarGroup && sidebarGroup.pages?.length) {
+            processSidebarItems(sidebarGroup.pages);
+        }
+    });
+
+    // Helper function to process sidebar items recursively
+    function processSidebarItems(items: Sidebar[] | PageURL[]) {
+        items.forEach(item => {
+            if (typeof item === 'string') {
+                paths.push(`/${item}`);
+                return
+            }
+
+            // Add the route of the sidebar group
+            if ('route' in item) {
+                const route = item.route;
+                if (route) {
+                    paths.push(`/${route}`);
+                }
+            }
+
+            // If item has pages, process them
+            if ("pages" in item && item.pages?.length) {
+                item.pages.forEach((page) => {
+                    if (typeof page === 'string') {
+                        // Add the page path
+                        paths.push(`/${page}`);
+                    } else {
+                        if ("virtual" in page) {
+                            paths.push(`/${page.page}`);
+                        } else {
+                            // Recursively process nested pages
+                            processSidebarItems([page]);
+                        }
+                    }
+                });
+            }
+        });
+    }
+
+    return paths;
+}

package/app/entry.client.tsx

@@ -0,0 +1,58 @@
+import { startTransition, StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+import { HydratedRouter } from "react-router/dom";
+
+// TODO: !!! BETTER !!! - needed cuz issues with rerender in react-router hash change
+(() => {
+  var _wr = function (type: 'pushState' | 'replaceState') {
+    var orig = history[type];
+    return function (data: any, unused: string, url?: string | URL | null) {
+      var rv = orig.call(history, data, unused, url);
+      var e = new Event(type);
+      (e as any).arguments = arguments;
+      window.dispatchEvent(e);
+      return rv;
+    };
+  };
+  history.replaceState = _wr('replaceState')
+})()
+
+console.log(`+-----------------------------------------------------------------------------------------------------------------------------+
+|                                                                                                                             |
+|                                                                                              dddddddd                       |
+|               ///////                                                                        d::::::d                       |
+|              /:::::/                                                                         d::::::d          >>>>>>>      |
+|             /:::::/                                                                          d::::::d           >:::::>     |
+|            /:::::/                                                                           d::::::d             >:::::>   |
+|           /:::::/         xxxxxxx      xxxxxxx     yyyyyyy           yyyyyyy         ddddddddd:::::d              >:::::>   |
+|          /:::::/           x:::::x    x:::::x       y:::::y         y:::::y        dd::::::::::::::d               >:::::>  |
+|         /:::::/             x:::::x  x:::::x         y:::::y       y:::::y        d::::::::::::::::d                >:::::> |
+|        /:::::/               x:::::xx:::::x           y:::::y     y:::::y        d:::::::ddddd:::::d                 >:::::>|
+|       /:::::/                 x::::::::::x             y:::::y   y:::::y         d::::::d    d:::::d                >:::::> |
+|      /:::::/                   x::::::::x               y:::::y y:::::y          d:::::d     d:::::d               >:::::>  |
+|     /:::::/                    x::::::::x                y:::::y:::::y           d:::::d     d:::::d              >:::::>   |
+|    /:::::/                    x::::::::::x                y:::::::::y            d:::::d     d:::::d             >:::::>    |
+|   /:::::/                    x:::::xx:::::x                y:::::::y             d::::::ddddd::::::dd           >:::::>     |
+|  /:::::/                    x:::::x  x:::::x                y:::::y               d:::::::::::::::::d          >>>>>>>      |
+| /:::::/                    x:::::x    x:::::x              y:::::y                 d:::::::::ddd::::d                       |
+|///////                    xxxxxxx      xxxxxxx            y:::::y                   ddddddddd   ddddd                       |
+|                                                          y:::::y                                                            |
+|                                                         y:::::y                                                             |
+|                                                        y:::::y                                                              |
+|                                                       y:::::y                                                               |
+|                                                      yyyyyyy                                                                |
+|                                                                                                                             |
+|                                                                                                                             |
+| Check out https://github.com/livesession/xyd                                                                                |
++-----------------------------------------------------------------------------------------------------------------------------+
+`)
+
+
+startTransition(() => {
+  hydrateRoot(
+    document,
+    <StrictMode>
+      <HydratedRouter />
+    </StrictMode>
+  );
+});

package/app/entry.server.tsx

@@ -0,0 +1,68 @@
+import { PassThrough } from "node:stream";
+
+import type { AppLoadContext, EntryContext } from "react-router";
+import { createReadableStreamFromReadable } from "@react-router/node";
+import { ServerRouter } from "react-router";
+import { isbot } from "isbot";
+import type { RenderToPipeableStreamOptions } from "react-dom/server";
+import { renderToPipeableStream } from "react-dom/server";
+
+export const streamTimeout = 5_000;
+
+export default function handleRequest(
+  request: Request,
+  responseStatusCode: number,
+  responseHeaders: Headers,
+  routerContext: EntryContext,
+  loadContext: AppLoadContext
+) {
+  return new Promise((resolve, reject) => {
+    let shellRendered = false;
+    let userAgent = request.headers.get("user-agent");
+
+    // Ensure requests from bots and SPA Mode renders wait for all content to load before responding
+    // https://react.dev/reference/react-dom/server/renderToPipeableStream#waiting-for-all-content-to-load-for-crawlers-and-static-generation
+    let readyOption: keyof RenderToPipeableStreamOptions =
+      (userAgent && isbot(userAgent)) || routerContext.isSpaMode
+        ? "onAllReady"
+        : "onShellReady";
+
+    const { pipe, abort } = renderToPipeableStream(
+      <ServerRouter context={routerContext} url={request.url} />,
+      {
+        [readyOption]() {
+          shellRendered = true;
+          const body = new PassThrough();
+          const stream = createReadableStreamFromReadable(body);
+
+          responseHeaders.set("Content-Type", "text/html");
+
+          resolve(
+            new Response(stream, {
+              headers: responseHeaders,
+              status: responseStatusCode,
+            })
+          );
+
+          pipe(body);
+        },
+        onShellError(error: unknown) {
+          reject(error);
+        },
+        onError(error: unknown) {
+          responseStatusCode = 500;
+          // Log streaming rendering errors from inside the shell.  Don't log
+          // errors encountered during initial shell rendering since they'll
+          // reject and get logged in handleDocumentRequest.
+          if (shellRendered) {
+            console.error(error);
+          }
+        },
+      }
+    );
+
+    // Abort the rendering stream after the `streamTimeout` so it has tine to
+    // flush down the rejected boundaries
+    setTimeout(abort, streamTimeout + 1000);
+  });
+}

package/app/pathRoutes.ts

@@ -0,0 +1,61 @@
+import path from "node:path";
+
+import { Settings } from "@xyd-js/core";
+import { layout, route } from "@react-router/dev/routes";
+
+type Route = {
+    id: string
+    path: string
+}
+
+// Helper function to recursively extract route definitions from nested pages
+export function pathRoutes(basePath: string, navigation: Settings['navigation']) {
+    if (!navigation?.sidebar) return [];
+
+    const routes: Route[] = [];
+
+    // Process each sidebar group
+    extractNestedRoutes(navigation.sidebar || [], routes)
+
+    if (!routes.length) {
+        return [
+            layout(path.join(basePath, "src/pages/layout.tsx"), [
+                route("/*", path.join(basePath, "src/pages/page.tsx"))
+            ])
+        ]
+    }
+
+    return routes.map(r => {
+        return layout(path.join(basePath, "src/pages/layout.tsx"), { id: `layout:${r.id}` }, [
+            route(r.path, path.join(basePath, "src/pages/page.tsx"), { id: r.id })
+        ])
+    })
+}
+
+
+function extractNestedRoutes(
+    sidebarItems: any[],
+    routes: Route[],
+    parentRoute?: string,
+) {
+    sidebarItems.forEach(item => {
+        if (item && typeof item === "object") {
+            let route = ""
+
+            // Only extract routes from items that have a "route" property
+            if ('route' in item && item.route) {
+                route = item.route
+                const routeMatch = item.route.startsWith("/") ? item.route : `/${item.route}`;
+                routes.push({ id: routeMatch, path: routeMatch + "/*" });
+            }
+
+            // Recursively process nested pages within this route
+            if (item.pages && Array.isArray(item.pages)) {
+                extractNestedRoutes(item.pages, routes, route || parentRoute)
+            }
+        } else if (!parentRoute) {
+            const page = item.startsWith("/") ? item : `/${item}`;
+            routes.push({ id: page, path: page });
+        }
+    });
+}

package/app/public.ts

@@ -0,0 +1,42 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+
+import { redirect } from "react-router";
+
+const MIME_TYPES: Record<string, string> = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.txt': 'text/plain',
+};
+
+const BINARY_FILE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.ico'];
+
+export async function loader({ params }: any) {
+    const filePath = path.join(process.cwd(), "public", params["*"])
+    
+    try {
+        await fs.access(filePath)
+    } catch (e) {
+        return redirect("/404")
+    }
+
+    const ext = path.extname(filePath).toLowerCase();
+    const isBinaryFile = BINARY_FILE_EXTENSIONS.includes(ext);
+    const fileContent = await fs.readFile(filePath, isBinaryFile ? null : 'utf-8');
+    const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+
+    return new Response(fileContent, {
+        status: 200,
+        headers: {
+            'Content-Type': contentType,
+        },
+    });
+}

package/app/raw.ts

@@ -0,0 +1,31 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+
+import { redirect } from "react-router";
+
+const MIME_TYPES: Record<string, string> = {
+    '.md': 'text/markdown',
+    '.mdx': 'text/markdown',
+};
+
+// TODO: !!! FINISH !!!
+export async function loader({ params }: any) {
+    const filePath = path.join(process.cwd(), "/docs/guides/quickstart.md")
+    
+    try {
+        await fs.access(filePath)
+    } catch (e) {
+        return redirect("/404")
+    }
+
+    const ext = path.extname(filePath).toLowerCase();
+    const fileContent = await fs.readFile(filePath, 'utf-8');
+    const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+
+    return new Response(fileContent, {
+        status: 200,
+        headers: {
+            'Content-Type': contentType,
+        },
+    });
+}

package/app/robots.ts

@@ -0,0 +1,18 @@
+export async function loader({ request }: { request: Request }) {
+    const baseUrl = __xydSettings?.seo?.domain || new URL(request.url).origin;
+    
+    // Generate robots.txt content
+    const content = `# https://www.robotstxt.org/robotstxt.html
+User-agent: *
+Allow: /
+
+# Sitemap
+Sitemap: ${baseUrl}/sitemap.xml`;
+
+    return new Response(content, {
+        headers: {
+            'Content-Type': 'text/plain',
+            'Cache-Control': 'public, max-age=3600'
+        }
+    });
+}

package/app/root.tsx

@@ -0,0 +1,82 @@
+import React, { } from "react";
+import { Links, Meta, Outlet, Scripts, ScrollRestoration } from "react-router";
+
+import { XYDAnalytics } from "@xyd-js/analytics";
+// @ts-ignore
+import { loadProvider } from 'virtual:xyd-analytics-providers'
+// @ts-ignore
+import virtualSettings from "virtual:xyd-settings";
+// @ts-ignore
+const { settings } = virtualSettings
+
+// const settings = globalThis.__xydSettings
+const DEFAULT_FAVICON_PATH = "/public/favicon.png";
+
+const faviconPath = settings?.theme?.favicon || DEFAULT_FAVICON_PATH
+const head = settings?.theme?.head || []
+
+type HeadTag = 'meta' | 'link' | 'title' | 'script' | 'style'
+
+export function Layout({ children }: { children: React.ReactNode }) {
+    const colorScheme = settings?.theme?.defaultColorScheme || "os"
+
+    return (
+        <html lang="en" data-color-scheme={colorScheme}>
+            <head>
+
+                {/* Inline script to prevent flash of unstyled content */}
+                <script
+                    dangerouslySetInnerHTML={{
+                        __html: `
+                        (function() {
+                            try {
+                                var theme = localStorage.getItem('xyd-color-scheme') || 'auto';
+                                var isDark = false;
+                                
+                                if (theme === 'dark') {
+                                    isDark = true;
+                                } else if (theme === 'auto') {
+                                    isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+                                }
+                                
+                                if (isDark) {
+                                    document.documentElement.setAttribute('data-color-scheme', 'dark');
+                                }
+                            } catch (e) {
+                                // Fallback to system preference if localStorage fails
+                                if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+                                    document.documentElement.setAttribute('data-color-scheme', 'dark');
+                                }
+                            }
+                        })();
+                    `
+                    }}
+                />
+                <meta charSet="utf-8" />
+                <meta name="viewport" content="width=device-width, initial-scale=1" />
+
+                <link rel="icon" type="image/png" sizes="32x32" href={faviconPath}></link>
+
+
+                {head.map(([tag, props]: [HeadTag, Record<string, string | boolean>], index: number) => {
+                    return React.createElement(tag, { key: index, ...props })
+                })}
+
+                <Meta />
+                <Links />
+            </head>
+            <XYDAnalytics settings={settings} loader={loadProvider}>
+                <body>
+                    {children}
+                    <ScrollRestoration />
+                    <Scripts />
+                </body>
+            </XYDAnalytics>
+        </html>
+    );
+}
+
+export default function App() {
+    return <Outlet />;
+}
+

package/app/routes.ts

@@ -0,0 +1,34 @@
+import {
+    route,
+} from "@react-router/dev/routes";
+import {pathRoutes} from "./pathRoutes";
+
+// Declare the global property type
+declare global {
+    var __xydBasePath: string;
+}
+
+const basePath = globalThis.__xydBasePath
+
+const navigation = __xydSettings?.navigation || {sidebar: []};
+const docsRoutes = pathRoutes(basePath, navigation)
+
+// TODO: !!!! if not routes found then '*' !!!
+export const routes = [
+    ...docsRoutes,
+
+    // TODO: in the future better sitemap + robots.txt
+    route("/sitemap.xml", "./sitemap.ts"),
+    route("/robots.txt", "./robots.ts"),
+    route(
+        "/.well-known/appspecific/com.chrome.devtools.json",
+        "./debug-null.tsx",
+    ),
+]
+
+if (globalThis.__xydStaticFiles?.length) {
+    routes.push(route("/public/*", "./public.ts"))
+}
+
+export default routes
+

package/app/sitemap.ts

@@ -0,0 +1,40 @@
+import {docPaths} from "./docPaths";
+
+const navigation = __xydSettings?.navigation || {sidebar: []};
+
+
+// TODO: support lastmod and other advanced features
+
+export async function loader({request}: { request: Request }) {
+    if (!navigation?.sidebar) {
+        return new Response('', {
+            status: 404,
+            headers: {
+                'Content-Type': 'text/plain'
+            }
+        });
+    }
+
+    const routes: string[] = docPaths(navigation);
+    const baseUrl = __xydSettings?.seo?.domain || new URL(request.url).origin;
+
+    // Generate XML sitemap
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${routes.map(route => {
+        const fullUrl = `${baseUrl}${route}`.replace(/([^:]\/)\/+/g, "$1"); // Remove duplicate slashes
+        return `  <url>
+    <loc>${fullUrl}</loc>
+    <changefreq>daily</changefreq>
+    <priority>0.7</priority>
+  </url>`;
+    }).join('\n')}
+</urlset>`;
+
+    return new Response(xml, {
+        headers: {
+            'Content-Type': 'application/xml',
+            'Cache-Control': 'public, max-age=3600'
+        }
+    });
+}

package/auto-imports.d.ts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+// Generated by unplugin-auto-import
+// biome-ignore lint: disable
+export {}
+declare global {
+
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@xyd-js/host",
+  "version": "0.1.0-xyd.2",
+  "type": "module",
+  "dependencies": {
+    "@react-router/dev": "^7.5.0",
+    "@react-router/node": "^7.5.0",
+    "@react-router/serve": "^7.5.0",
+    "isbot": "^5",
+    "react-router": "^7.5.0",
+    "@xyd-js/core": "0.1.0-xyd.15",
+    "@xyd-js/components": "0.1.0-xyd.13",
+    "@xyd-js/framework": "0.1.0-xyd.34",
+    "@xyd-js/composer": "0.1.0-xyd.2",
+    "@xyd-js/themes": "0.1.1-xyd.5",
+    "@xyd-js/theme-poetry": "0.1.0-xyd.29",
+    "@xyd-js/theme-opener": "0.1.0-xyd.2",
+    "@xyd-js/theme-cosmo": "0.1.0-xyd.2",
+    "@xyd-js/theme-picasso": "0.1.0-xyd.2",
+    "@xyd-js/plugin-orama": "0.1.0-xyd.2",
+    "@xyd-js/plugin-algolia": "0.1.0-xyd.2",
+    "@xyd-js/atlas": "0.1.0-xyd.18"
+  },
+  "devDependencies": {
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.47",
+    "semver": "^7.6.3",
+    "vite": "^6.1.0",
+    "vite-tsconfig-paths": "^5.1.4"
+  },
+  "scripts": {}
+}

package/plugins/README.md

@@ -0,0 +1 @@
+xyd plugins

package/postcss.config.cjs

@@ -0,0 +1,5 @@
+module.exports = {
+    plugins: {
+        autoprefixer: {},
+    },
+}

package/react-router.config.ts

@@ -0,0 +1,94 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+
+import type {Config} from "@react-router/dev/config";
+
+import {Settings} from "@xyd-js/core";
+import {docPaths} from "./app/docPaths";
+
+declare global {
+    var __xydSettings: Settings;
+    var __xydStaticFiles: string[];
+}
+
+// Function to get all static files from the public directory
+async function getStaticFiles() {
+    const publicDir = path.join(process.cwd(), "public");
+    const paths: string[] = [];
+
+    try {
+        await fs.access(publicDir);
+    } catch (e) {
+        return paths;
+    }
+
+    async function scanDirectory(dir: string, basePath: string = "") {
+        const entries = await fs.readdir(dir, {withFileTypes: true});
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.join(basePath, entry.name);
+
+            if (entry.isDirectory()) {
+                await scanDirectory(fullPath, relativePath);
+            } else {
+                paths.push(`/public/${relativePath}`);
+            }
+        }
+    }
+
+    await scanDirectory(publicDir);
+    return paths;
+}
+
+// Function to find documentation files for navigation paths
+// async function findDocFiles(navigationPaths: string[]) {
+//     const docFiles: string[] = [];
+//
+//     for (const navPath of navigationPaths) {
+//         // Try .mdx first, then .md
+//         const mdxPath = path.join(process.cwd(), navPath + '.mdx');
+//         const mdPath = path.join(process.cwd(), navPath + '.md');
+//
+//         try {
+//             await fs.access(mdxPath);
+//             docFiles.push(navPath + ".mdx");
+//         } catch {
+//             try {
+//                 await fs.access(mdPath);
+//                 docFiles.push(navPath + ".md");
+//             } catch {
+//             }
+//         }
+//     }
+//
+//     return docFiles;
+// }
+
+// Use settings.navigation if it exists, otherwise use an empty object
+const navigation = __xydSettings?.navigation || {sidebar: []};
+const navigationPaths = docPaths(navigation);
+
+// Get static files and documentation files
+const staticFiles = await getStaticFiles();
+// const docFiles = await findDocFiles(navigationPaths);
+
+globalThis.__xydStaticFiles = staticFiles
+
+// Combine all paths for prerendering
+const prerenderPaths = [
+    ...navigationPaths,
+    ...staticFiles,
+
+    "/sitemap.xml",
+    "/robots.txt",
+    // ...docFiles,
+];
+const cwd = process.cwd();
+
+export default {
+    ssr: false,
+    prerender: prerenderPaths,
+    buildDirectory: path.join(cwd, ".xyd/build"),
+    // return a list of URLs to prerender at build time
+} satisfies Config;

package/src/auto-imports.d.ts

@@ -0,0 +1,29 @@
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+// Generated by unplugin-auto-import
+// biome-ignore lint: disable
+export {}
+declare global {
+  const createRef: typeof import('react')['createRef']
+  const forwardRef: typeof import('react')['forwardRef']
+  const lazy: typeof import('react')['lazy']
+  const memo: typeof import('react')['memo']
+  const startTransition: typeof import('react')['startTransition']
+  const useCallback: typeof import('react')['useCallback']
+  const useContext: typeof import('react')['useContext']
+  const useDebugValue: typeof import('react')['useDebugValue']
+  const useDeferredValue: typeof import('react')['useDeferredValue']
+  const useEffect: typeof import('react')['useEffect']
+  const useId: typeof import('react')['useId']
+  const useImperativeHandle: typeof import('react')['useImperativeHandle']
+  const useInsertionEffect: typeof import('react')['useInsertionEffect']
+  const useLayoutEffect: typeof import('react')['useLayoutEffect']
+  const useMemo: typeof import('react')['useMemo']
+  const useReducer: typeof import('react')['useReducer']
+  const useRef: typeof import('react')['useRef']
+  const useState: typeof import('react')['useState']
+  const useSyncExternalStore: typeof import('react')['useSyncExternalStore']
+  const useTransition: typeof import('react')['useTransition']
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": [
+      "ES2020",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "typeRoots": [
+      "./types.d.ts"
+    ],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": false,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "jsx": "react-jsx",
+    "include": [
+      "./types.d.ts"
+    ]
+  }
+}

package/types.d.ts

@@ -0,0 +1,8 @@
+// declarations.d.ts
+
+declare global {
+    var __xydBasePath: string;
+
+    var __xydSettings: Settings;
+  }
+  

package/vite.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vite';
+
+// DO NOT DELETE
+// This file is needed for host `vite` to run
+export default defineConfig({
+    plugins: [
+    ],
+});