@xyd-js/host 0.1.0-build.158

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,69 @@
+import {PageURL, Settings, Sidebar} from "@xyd-js/core";
+
+export function docPaths(navigation: Settings['navigation']) {
+    if (!navigation?.sidebar) return [];
+
+    const paths: string[] = [];
+
+    if (globalThis.__xydHasIndexPage) {
+        paths.push("/")
+    }
+
+    // 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,86 @@
+import path from "node:path";
+
+import { RouteConfigEntry, index } from "@react-router/dev/routes";
+
+import { Settings, SidebarNavigation } 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) {
+        const rrRoutes: RouteConfigEntry[] = []
+        if (globalThis.__xydHasIndexPage) {
+            rrRoutes.push(
+                index(path.join(basePath, "src/pages/page.tsx"))
+            )
+        } else {
+            rrRoutes.push(
+                route("/*", path.join(basePath, "src/pages/page.tsx"))
+            )
+        }
+
+        return [
+            layout(path.join(basePath, "src/pages/layout.tsx"), [
+                ...rrRoutes
+            ])
+        ]
+    }
+
+    const rrRoutes: RouteConfigEntry[] = []
+    if (globalThis.__xydHasIndexPage) {
+        rrRoutes.push(
+            layout(path.join(basePath, "src/pages/layout.tsx"), { id: `layout:index` }, [
+                index(path.join(basePath, "src/pages/page.tsx"))
+            ])
+        )
+    }
+
+    return [
+        ...rrRoutes,
+        ...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: SidebarNavigation,
+    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 as SidebarNavigation, 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,43 @@
+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',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.txt': 'text/plain',
+};
+
+const BINARY_FILE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp'];
+
+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'
+        }
+    });
+}