xanix 0.0.0 → 1.0.0

package/dist/server/runtime/readManifest.d.ts

@@ -0,0 +1,14 @@
+interface XanixManifestEntry {
+    id: string;
+    name: string;
+    file: string;
+    path: string;
+    build: string;
+    export: string;
+}
+interface XanixManifest {
+    version: number;
+    entries: XanixManifestEntry[];
+}
+declare function readManifest(): Promise<XanixManifest>;
+export default readManifest;

package/dist/server/runtime/readManifest.js

@@ -0,0 +1,8 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+async function readManifest() {
+    const manifestPath = path.resolve(process.cwd(), ".xanix", "client-manifest.json");
+    const source = await fs.readFile(manifestPath, "utf8");
+    return JSON.parse(source);
+}
+export default readManifest;

package/dist/server/runtime/xanixPage.d.ts

@@ -0,0 +1,9 @@
+interface XanixPageProps {
+    pageId: string;
+    req: any;
+    res: any;
+    Component: (props: Record<string, any>) => React.ReactElement;
+    props: Record<string, any>;
+}
+export default function xanixPage({ pageId, req, res, Component, props, }: XanixPageProps): Promise<string | undefined>;
+export {};

package/dist/server/runtime/xanixPage.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderToPipeableStream, renderToString } from "react-dom/server";
+import readManifest from "./readManifest.js";
+import { PassThrough } from "node:stream";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import dataLoader from "../../dataLoader.js";
+function renderPage(element) {
+    return new Promise((resolve, reject) => {
+        let html = "";
+        const stream = new PassThrough();
+        stream.on("data", (chunk) => {
+            html += chunk.toString();
+        });
+        stream.on("end", () => {
+            resolve(html);
+        });
+        stream.on("error", reject);
+        let didError = false;
+        const { pipe, abort } = renderToPipeableStream(element, {
+            onAllReady() {
+                pipe(stream);
+            },
+            onError(error) {
+                didError = true;
+                console.error("SSR error:", error);
+            },
+            onShellError(error) {
+                reject(error);
+            },
+        });
+        // Optional timeout protection
+        setTimeout(() => {
+            abort();
+        }, 10_000);
+    });
+}
+export default async function xanixPage({ pageId, req, res, Component, props, }) {
+    const manifest = await readManifest();
+    const { title, meta } = req.XanixPageData;
+    const entry = manifest.entries.find((item) => item.id === pageId);
+    const method = req.method.toUpperCase();
+    if (method !== "GET") {
+        res.status(405).send("Method Not Allowed");
+        return;
+    }
+    if (!entry) {
+        res.status(404).send("Page Not Found");
+        return;
+    }
+    const Document = (await import(pathToFileURL(path.join(process.cwd(), ".xanix", "xanix-document.js"))
+        .href)).default;
+    if (!dataLoader.isInit(pageId)) {
+        renderToString(_jsx(Document, { document: {
+                pageId,
+                props,
+                title: title ?? entry.name.replaceAll("-", " "),
+                meta,
+                params: req.params,
+                request: req,
+                pageData: {},
+            }, children: _jsx(Component, { ...props }) }));
+    }
+    const pageData = await dataLoader.results(pageId);
+    if ("x-navigation" in req.headers) {
+        res.setHeader("Content-Type", "application/json");
+        return JSON.stringify({
+            pageId,
+            props,
+            title: title ?? entry.name.replaceAll("-", " "),
+            meta,
+            params: req.params,
+            request: null,
+            pageData,
+        });
+    }
+    const html = await renderPage(_jsx(Document, { document: {
+            pageId,
+            props,
+            title: title ?? entry.name.replaceAll("-", " "),
+            meta,
+            params: req.params,
+            request: req,
+            pageData,
+        }, children: _jsx(Component, { ...props }) }));
+    return `<!DOCTYPE html>${html}`;
+}

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+import "express";
+declare global {
+    namespace Express {
+        interface Request {
+            document: {
+                setTitle(title: string): void;
+                setMeta(name: string, content: string): void;
+            };
+        }
+    }
+}
+export {};

package/dist/types.js

@@ -0,0 +1,7 @@
+import "express";
+// export type XanixDocumentData = {
+//   pageId: string;
+//   props: Record<string, any>;
+//   title: string;
+//   meta: Array<{ name: string; content: string }>;
+// };

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+export declare const getGlobal: () => any;
+export declare const getGlobalXanix: () => Record<string, any>;
+export type DocumentData = {
+    head: ReactNode;
+    body: ReactNode;
+};
+export declare const getDocumentData: () => DocumentData;
+export declare const getDocumentFile: () => Promise<string>;

package/dist/utils/index.js

@@ -0,0 +1,27 @@
+export const getGlobal = () => {
+    if (typeof window === "undefined") {
+        return globalThis;
+    }
+    else {
+        return window;
+    }
+};
+export const getGlobalXanix = () => {
+    const global = getGlobal();
+    global.Xanix = global.Xanix || {};
+    return global.Xanix;
+};
+export const getDocumentData = () => {
+    const global = getGlobal();
+    global.DocumentData = global.DocumentData || {};
+    return global.DocumentData;
+};
+import fs from "node:fs";
+import path from "node:path";
+export const getDocumentFile = async () => {
+    const documentEntry = path.join(process.cwd(), ".xanix", "xanix-document.js");
+    if (fs.existsSync(documentEntry)) {
+        return documentEntry;
+    }
+    throw new Error(`Document file not found at ${documentEntry}`);
+};

package/dist/xanix.d.ts

@@ -0,0 +1,3 @@
+import type { Request, Response } from "express";
+declare const xanix: () => (_req: Request, res: Response, next: any) => Promise<void>;
+export default xanix;

package/dist/xanix.js

@@ -0,0 +1,40 @@
+import { renderToString } from "react-dom/server";
+import { isValidElement } from "react";
+const xanix = () => {
+    return async (_req, res, next) => {
+        const originalSend = res.send.bind(res);
+        res.send = async (component) => {
+            if (typeof component !== "object" || !isValidElement(component)) {
+                originalSend(component);
+                return;
+            }
+            // const { title, description } = component.type.metadata || {};
+            if (_req.query.static) {
+                res.setHeader("Content-Type", "application/json");
+                originalSend(JSON.stringify({
+                    source: "script.js",
+                    props: component.props,
+                }));
+            }
+            else {
+                const html = renderToString(component);
+                res.setHeader("Content-Type", "text/html");
+                originalSend(`
+        <!doctype html>
+        <html>
+          <head>
+          </head>
+          <body>
+            <div>${html}</div>
+            <script>
+              window.__INITIAL_PROPS__ = ${JSON.stringify(component.props)};
+            </script>
+          </body>
+        </html>
+      `);
+            }
+        };
+        next();
+    };
+};
+export default xanix;

package/package.json

@@ -1,13 +1,73 @@
-{
-  "name": "xanix",
-  "version": "0.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "Naxrul Ahmed",
-  "license": "ISC",
-  "type": "commonjs"
-}
+{
+  "name": "xanix",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": "./dist/bin/index.js",
+  "type": "module",
+  "files": [
+    "dist",
+    "src/xanix-env.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./page": {
+      "import": "./dist/server/page.js",
+      "require": "./dist/server/page.js"
+    },
+    "./runtime": {
+      "import": "./dist/server/runtime/index.js",
+      "require": "./dist/server/runtime/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsc --watch --preserveWatchOutput",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": [],
+  "author": "Naxrul Ahmed",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/generator": "^8.0.0",
+    "@babel/parser": "^8.0.4",
+    "@babel/traverse": "^8.0.4",
+    "@rollup/plugin-alias": "^6.0.0",
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-url": "^8.0.2",
+    "commander": "^15.0.0",
+    "dotenv": "^17.4.2",
+    "esbuild": "^0.28.2",
+    "express": "^5.2.1",
+    "picocolors": "^1.1.1",
+    "react-refresh": "^0.18.0",
+    "rollup": "^4.62.5",
+    "rollup-plugin-esbuild": "^6.2.1",
+    "tslib": "^2.8.1",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.2.0",
+    "@types/prompts": "^2.4.9",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@types/react-refresh": "^0.14.7",
+    "@types/ws": "^8.18.1",
+    "@xanui/core": "^1.3.38",
+    "@xanui/icons": "^1.1.14",
+    "@xanui/ui": "^1.2.24",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "typescript": "^5.9.3"
+  }
+}

package/src/xanix-env.d.ts

@@ -0,0 +1,79 @@
+import "express";
+
+declare global {
+  const __XANIX_CLIENT__: boolean;
+  const __XANIX_SERVER__: boolean;
+  const __XANIX_DEV__: boolean;
+  const __XANIX_PROD__: boolean;
+}
+
+declare module "express-serve-static-core" {
+  interface Request {
+    page: {
+      setTitle(title: string): void;
+      setMeta(name: string, content: string): void;
+    };
+  }
+}
+
+declare module "*.png" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.jpg" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.jpeg" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.gif" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.webp" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.svg" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.ico" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.woff" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.woff2" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.ttf" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.eot" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.css" {
+  const src: string;
+  export default src;
+}
+
+export {};