xanix 1.0.10 → 1.0.12

package/dist/bin/bundler/plugins/XanixDocument/index.js

@@ -1,14 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-const __dirname = fileURLToPath(import.meta.url);
 const require = createRequire(import.meta.url);
 const VIRTUAL_ID = "virtual:xanix-document";
 const RESOLVED_ID = "\0virtual:xanix-document";
 export default function xanixDocument() {
     const root = process.cwd();
-    const userDocument = path.resolve(root, "Document.tsx");
+    const userDocument = path.resolve(root, "document.tsx");
     const baseDocument = require.resolve("../../../../../dist/components/BaseDocument.js");
     return {
         name: "xanix-document",

package/dist/bin/bundler/plugins/XanixPageTransform/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "rollup";
+export default function XanixPageTransform(): Plugin;

package/dist/bin/bundler/plugins/XanixPageTransform/index.js

@@ -0,0 +1,19 @@
+import { transformer } from "./transformer.js";
+export default function XanixPageTransform() {
+    return {
+        name: "xanix-page-transform",
+        async transform(code, id) {
+            if (id.includes("node_modules") || !/\.(tsx?|jsx?)$/.test(id)) {
+                return null;
+            }
+            const result = transformer(code, id);
+            if (!result) {
+                return null;
+            }
+            return {
+                code: result.code,
+                map: result.map,
+            };
+        },
+    };
+}

package/dist/bin/bundler/plugins/XanixPageTransform/transformer.d.ts

@@ -0,0 +1,16 @@
+import * as t from "@babel/types";
+export interface XanixTransformResult {
+    code: string;
+    map: any;
+}
+export declare function resolveFile(file: string): string;
+export declare function resolveComponentFile(importer: string, importPath: string): string;
+export declare function createPageId(file: string): string;
+export declare function getJSXComponentName(node: t.JSXElement): string | null;
+export declare function findComponentImport(ast: t.File, componentName: string): {
+    file: string;
+    export: string;
+    declaration: t.ImportDeclaration;
+    specifier: t.ImportSpecifier | t.ImportDefaultSpecifier;
+} | null;
+export declare function transformer(code: string, id: string): XanixTransformResult | null;

package/dist/bin/bundler/plugins/XanixPageTransform/transformer.js

@@ -0,0 +1,501 @@
+import path from "node:path";
+import fs from "node:fs";
+import crypto from "node:crypto";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+const RUNTIME_IMPORT = "xanix/runtime";
+const SOURCE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+function normalizeFilePath(file) {
+    return path.resolve(file).split(path.sep).join("/");
+}
+export function resolveFile(file) {
+    const absolute = path.resolve(file);
+    if (fs.existsSync(absolute)) {
+        const stat = fs.statSync(absolute);
+        if (stat.isFile()) {
+            return absolute;
+        }
+    }
+    for (const ext of SOURCE_EXTENSIONS) {
+        const candidate = `${absolute}${ext}`;
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            return path.resolve(candidate);
+        }
+    }
+    if (fs.existsSync(absolute) && fs.statSync(absolute).isDirectory()) {
+        for (const ext of SOURCE_EXTENSIONS) {
+            const candidate = path.join(absolute, `index${ext}`);
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+                return path.resolve(candidate);
+            }
+        }
+    }
+    return absolute;
+}
+export function resolveComponentFile(importer, importPath) {
+    if (!importPath.startsWith(".")) {
+        return importPath;
+    }
+    const base = path.resolve(path.dirname(importer), importPath);
+    return resolveFile(base);
+}
+export function createPageId(file) {
+    return `c_${crypto
+        .createHash("sha256")
+        .update(path.normalize(file))
+        .digest("hex")
+        .slice(0, 12)}`;
+}
+export function getJSXComponentName(node) {
+    const name = node.openingElement.name;
+    if (t.isJSXIdentifier(name)) {
+        return name.name;
+    }
+    if (t.isJSXMemberExpression(name)) {
+        if (t.isJSXIdentifier(name.object) && t.isJSXIdentifier(name.property)) {
+            return `${name.object.name}.${name.property.name}`;
+        }
+    }
+    return null;
+}
+export function findComponentImport(ast, componentName) {
+    for (const node of ast.program.body) {
+        if (!t.isImportDeclaration(node)) {
+            continue;
+        }
+        for (const specifier of node.specifiers) {
+            if (t.isImportDefaultSpecifier(specifier) &&
+                specifier.local.name === componentName) {
+                return {
+                    file: node.source.value,
+                    export: "default",
+                    declaration: node,
+                    specifier,
+                };
+            }
+            if (t.isImportSpecifier(specifier) &&
+                specifier.local.name === componentName) {
+                const imported = specifier.imported;
+                return {
+                    file: node.source.value,
+                    export: t.isIdentifier(imported) ? imported.name : imported.value,
+                    declaration: node,
+                    specifier,
+                };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Remove a specific component from:
+ *
+ * import Home from "./Home";
+ *
+ * or:
+ *
+ * import Home, { foo } from "./Home";
+ *
+ * or:
+ *
+ * import { Home, foo } from "./Home";
+ */
+function removeComponentImport(componentImport) {
+    const { declaration, specifier } = componentImport;
+    const index = declaration.specifiers.indexOf(specifier);
+    if (index !== -1) {
+        declaration.specifiers.splice(index, 1);
+    }
+}
+function removeEmptyImportDeclarations(ast) {
+    ast.program.body = ast.program.body.filter((statement) => {
+        if (!t.isImportDeclaration(statement)) {
+            return true;
+        }
+        return statement.specifiers.length > 0;
+    });
+}
+/**
+ * Create:
+ *
+ * const Home =
+ *   (await import("./Home")).default;
+ *
+ * or:
+ *
+ * const Home =
+ *   (await import("./Home")).Home;
+ */
+function createDynamicComponentImport(componentName, importPath, exportName) {
+    const importCall = t.callExpression(t.import(), [
+        t.stringLiteral(importPath),
+    ]);
+    const awaitedImport = t.awaitExpression(importCall);
+    const property = exportName === "default"
+        ? t.identifier("default")
+        : t.identifier(exportName);
+    const value = t.memberExpression(awaitedImport, property);
+    return t.variableDeclaration("const", [
+        t.variableDeclarator(t.identifier(componentName), value),
+    ]);
+}
+/**
+ * Convert a JSX name into an expression.
+ *
+ * Example:
+ *
+ * <Home />
+ *
+ * becomes:
+ *
+ * Home
+ */
+function jsxNameToExpression(name) {
+    if (t.isJSXIdentifier(name)) {
+        return t.identifier(name.name);
+    }
+    if (t.isJSXMemberExpression(name)) {
+        const object = jsxNameToExpressionFromJSXName(name.object);
+        const property = jsxNameToExpressionFromJSXName(name.property);
+        if (!object || !property) {
+            return null;
+        }
+        return t.memberExpression(object, property);
+    }
+    return null;
+}
+function jsxNameToExpressionFromJSXName(name) {
+    if (t.isJSXIdentifier(name)) {
+        return t.identifier(name.name);
+    }
+    if (t.isJSXMemberExpression(name)) {
+        const object = jsxNameToExpressionFromJSXName(name.object);
+        const property = jsxNameToExpressionFromJSXName(name.property);
+        if (!object || !property) {
+            return null;
+        }
+        return t.memberExpression(object, property);
+    }
+    return null;
+}
+/**
+ * Convert JSX attributes into an object expression.
+ *
+ * Example:
+ *
+ * <Home
+ *   name="Naxrul"
+ *   age={30}
+ *   active
+ *   {...user}
+ * />
+ *
+ * becomes:
+ *
+ * {
+ *   name: "Naxrul",
+ *   age: 30,
+ *   active: true,
+ *   ...user
+ * }
+ */
+function jsxAttributesToProps(jsx) {
+    const properties = [];
+    for (const attribute of jsx.openingElement.attributes) {
+        /**
+         * Handle:
+         *
+         * {...props}
+         */
+        if (t.isJSXSpreadAttribute(attribute)) {
+            properties.push(t.spreadElement(attribute.argument));
+            continue;
+        }
+        /**
+         * Normal JSX attribute:
+         *
+         * name="value"
+         * name={value}
+         * active
+         */
+        if (!t.isJSXAttribute(attribute)) {
+            continue;
+        }
+        function jsxAttributeNameToExpression(name) {
+            if (t.isJSXIdentifier(name)) {
+                return t.identifier(name.name);
+            }
+            return t.stringLiteral(`${name.namespace.name}:${name.name.name}`);
+        }
+        const key = jsxAttributeNameToExpression(attribute.name);
+        /**
+         * Boolean JSX prop:
+         *
+         * <Home active />
+         *
+         * becomes:
+         *
+         * active: true
+         */
+        if (!attribute.value) {
+            properties.push(t.objectProperty(key, t.booleanLiteral(true)));
+            continue;
+        }
+        /**
+         * String prop:
+         *
+         * name="Naxrul"
+         *
+         * becomes:
+         *
+         * name: "Naxrul"
+         */
+        if (t.isStringLiteral(attribute.value)) {
+            properties.push(t.objectProperty(key, t.stringLiteral(attribute.value.value)));
+            continue;
+        }
+        /**
+         * Expression prop:
+         *
+         * age={30}
+         * user={user}
+         * items={items.map(...)}
+         */
+        if (t.isJSXExpressionContainer(attribute.value)) {
+            const expression = attribute.value.expression;
+            if (t.isJSXEmptyExpression(expression)) {
+                continue;
+            }
+            properties.push(t.objectProperty(key, expression));
+            continue;
+        }
+        /**
+         * JSX element as a prop:
+         *
+         * content={<div>Hello</div>}
+         */
+        if (t.isJSXElement(attribute.value)) {
+            properties.push(t.objectProperty(key, attribute.value));
+            continue;
+        }
+    }
+    return t.objectExpression(properties);
+}
+/**
+ * Convert:
+ *
+ * <Home name="Naxrul" age={30} />
+ *
+ * into:
+ *
+ * {
+ *   component: Home,
+ *   props: {
+ *     name: "Naxrul",
+ *     age: 30
+ *   }
+ * }
+ */
+function jsxToComponentAndProps(jsx) {
+    const component = jsxNameToExpression(jsx.openingElement.name);
+    if (!component) {
+        return null;
+    }
+    const props = jsxAttributesToProps(jsx);
+    return {
+        component,
+        props,
+    };
+}
+function hasRuntimeImport(ast, name) {
+    for (const statement of ast.program.body) {
+        if (!t.isImportDeclaration(statement)) {
+            continue;
+        }
+        if (statement.source.value !== RUNTIME_IMPORT) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (t.isImportSpecifier(specifier) &&
+                t.isIdentifier(specifier.imported) &&
+                specifier.imported.name === name) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function injectRuntimeImport(ast, name) {
+    if (hasRuntimeImport(ast, name)) {
+        return;
+    }
+    // Find existing:
+    // import { ... } from "xanix/runtime";
+    for (const statement of ast.program.body) {
+        if (!t.isImportDeclaration(statement)) {
+            continue;
+        }
+        if (statement.source.value !== RUNTIME_IMPORT) {
+            continue;
+        }
+        statement.specifiers.push(t.importSpecifier(t.identifier(name), t.identifier(name)));
+        return;
+    }
+    // No runtime import exists yet
+    ast.program.body.unshift(t.importDeclaration([t.importSpecifier(t.identifier(name), t.identifier(name))], t.stringLiteral(RUNTIME_IMPORT)));
+}
+export function transformer(code, id) {
+    const ast = parse(code, {
+        sourceType: "module",
+        plugins: ["typescript", "jsx"],
+    });
+    let changed = false;
+    traverse(ast, {
+        CallExpression(callPath) {
+            const call = callPath.node;
+            /**
+             * Find:
+             *
+             * res.send(<Home />);
+             */
+            if (!t.isMemberExpression(call.callee)) {
+                return;
+            }
+            if (!t.isIdentifier(call.callee.property, {
+                name: "send",
+            })) {
+                return;
+            }
+            const argument = call.arguments[0];
+            if (!argument || !t.isJSXElement(argument)) {
+                return;
+            }
+            const functionPath = callPath.getFunctionParent();
+            if (!functionPath) {
+                return;
+            }
+            const params = functionPath.node.params;
+            if (params.length < 2) {
+                return;
+            }
+            const requestParam = params[0];
+            const responseParam = params[1];
+            if (!t.isIdentifier(requestParam) || !t.isIdentifier(responseParam)) {
+                return;
+            }
+            const componentName = getJSXComponentName(argument);
+            if (!componentName) {
+                return;
+            }
+            const componentImport = findComponentImport(ast, componentName);
+            if (!componentImport) {
+                return;
+            }
+            const componentImportPath = componentImport.file;
+            const componentFile = resolveComponentFile(id, componentImportPath);
+            if (!path.isAbsolute(componentFile)) {
+                return;
+            }
+            const normalizedFile = normalizeFilePath(componentFile);
+            const pageId = createPageId(normalizedFile);
+            /**
+             * Convert:
+             *
+             * <Home name="Naxrul" age={30} />
+             *
+             * into:
+             *
+             * component: Home
+             *
+             * props: {
+             *   name: "Naxrul",
+             *   age: 30
+             * }
+             */
+            const componentAndProps = jsxToComponentAndProps(argument);
+            if (!componentAndProps) {
+                return;
+            }
+            /**
+             * Remove:
+             *
+             * import Home from "./Home";
+             */
+            removeComponentImport(componentImport);
+            /**
+             * Add:
+             *
+             * const Home =
+             *   (await import("./Home")).default;
+             */
+            const dynamicImport = createDynamicComponentImport(componentName, componentImportPath, componentImport.export);
+            /**
+             * Insert immediately before:
+             *
+             * res.send(<Home />);
+             */
+            const statementPath = callPath.getStatementParent();
+            if (statementPath) {
+                statementPath.insertBefore(dynamicImport);
+            }
+            /**
+             * Route becomes:
+             *
+             * async (req, res) => {}
+             */
+            if (t.isFunction(functionPath.node)) {
+                functionPath.node.async = true;
+            }
+            /**
+             * Replace:
+             *
+             * res.send(<Home />);
+             *
+             * with:
+             *
+             * res.send(
+             *   await xanixPage({
+             *     clientId,
+             *     req,
+             *     res,
+             *     component: Home,
+             *     props: {
+             *       ...
+             *     }
+             *   })
+             * );
+             */
+            const pageCall = t.awaitExpression(t.callExpression(t.identifier("xanixPage"), [
+                t.objectExpression([
+                    t.objectProperty(t.identifier("pageId"), t.stringLiteral(pageId)),
+                    t.objectProperty(t.identifier("req"), t.identifier(requestParam.name)),
+                    t.objectProperty(t.identifier("res"), t.identifier(responseParam.name)),
+                    t.objectProperty(t.identifier("Component"), componentAndProps.component),
+                    t.objectProperty(t.identifier("props"), componentAndProps.props),
+                ]),
+            ]));
+            call.arguments[0] = pageCall;
+            changed = true;
+        },
+    });
+    if (!changed) {
+        return null;
+    }
+    /**
+     * Add:
+     *
+     * import xanixPage from "xanix/page";
+     */
+    injectRuntimeImport(ast, "xanixPage");
+    /**
+     * Remove empty imports.
+     */
+    removeEmptyImportDeclarations(ast);
+    const output = generate(ast, {}, code);
+    return {
+        code: output.code,
+        map: output.map,
+    };
+}

package/dist/bin/bundler/plugins/XanixPageTransform.js

@@ -0,0 +1 @@
+"use strict";

package/dist/bin/bundler/plugins/XanixServerTransform.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "rollup";
+export interface XanixServerTransformOptions {
+    mode: "watch" | "start";
+}
+export default function XanixServerTransform(options: XanixServerTransformOptions): Plugin;

package/dist/bin/bundler/plugins/XanixServerTransform.js

@@ -0,0 +1,130 @@
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+const RUNTIME_IMPORT = "xanix/runtime";
+function findExpressServer(ast) {
+    let appName = null;
+    traverse(ast, {
+        CallExpression(path) {
+            const node = path.node;
+            // Find:
+            // app.listen(...)
+            if (!t.isMemberExpression(node.callee) ||
+                !t.isIdentifier(node.callee.property, {
+                    name: "listen",
+                }) ||
+                !t.isIdentifier(node.callee.object)) {
+                return;
+            }
+            const variableName = node.callee.object.name;
+            // Find the binding of `app`
+            const binding = path.scope.getBinding(variableName);
+            if (!binding || !binding.path.isVariableDeclarator()) {
+                return;
+            }
+            const init = binding.path.node.init;
+            // Confirm:
+            // const app = express();
+            if (t.isCallExpression(init) &&
+                t.isIdentifier(init.callee, {
+                    name: "express",
+                })) {
+                appName = variableName;
+                path.stop();
+            }
+        },
+    });
+    return appName;
+}
+function injectRuntimeImport(ast) {
+    let runtimeImport = null;
+    for (const statement of ast.program.body) {
+        if (t.isImportDeclaration(statement) &&
+            statement.source.value === RUNTIME_IMPORT) {
+            runtimeImport = statement;
+            break;
+        }
+    }
+    if (runtimeImport) {
+        const exists = runtimeImport.specifiers.some((specifier) => t.isImportSpecifier(specifier) &&
+            t.isIdentifier(specifier.imported, {
+                name: "createXanixServer",
+            }));
+        if (!exists) {
+            runtimeImport.specifiers.push(t.importSpecifier(t.identifier("createXanixServer"), t.identifier("createXanixServer")));
+        }
+        return;
+    }
+    ast.program.body.unshift(t.importDeclaration([
+        t.importSpecifier(t.identifier("createXanixServer"), t.identifier("createXanixServer")),
+    ], t.stringLiteral(RUNTIME_IMPORT)));
+}
+export default function XanixServerTransform(options) {
+    return {
+        name: "xanix-server-transform",
+        transform(code, id) {
+            // Ignore node_modules
+            if (id.includes("node_modules")) {
+                return null;
+            }
+            // Only process JS/TS files
+            if (!/\.[cm]?[jt]sx?$/.test(id)) {
+                return null;
+            }
+            let ast;
+            try {
+                ast = parse(code, {
+                    sourceType: "module",
+                    plugins: ["typescript", "jsx"],
+                });
+            }
+            catch {
+                return null;
+            }
+            // Find the REAL server app
+            const appName = findExpressServer(ast);
+            if (!appName) {
+                return null;
+            }
+            let changed = false;
+            traverse(ast, {
+                VariableDeclarator(path) {
+                    const node = path.node;
+                    // Only transform:
+                    // const app = express()
+                    if (!t.isIdentifier(node.id, {
+                        name: appName,
+                    })) {
+                        return;
+                    }
+                    if (!t.isCallExpression(node.init) ||
+                        !t.isIdentifier(node.init.callee, {
+                            name: "express",
+                        })) {
+                        return;
+                    }
+                    node.init = t.callExpression(t.identifier("createXanixServer"), [
+                        t.objectExpression([
+                            t.objectProperty(t.identifier("mode"), t.stringLiteral(options.mode)),
+                        ]),
+                    ]);
+                    changed = true;
+                    path.stop();
+                },
+            });
+            if (!changed) {
+                return null;
+            }
+            injectRuntimeImport(ast);
+            const output = generate(ast, {
+                sourceMaps: true,
+                sourceFileName: id,
+            }, code);
+            return {
+                code: output.code,
+                map: output.map,
+            };
+        },
+    };
+}

package/dist/bin/bundler/plugins/XanixTransform/index.d.ts

@@ -1,5 +1,2 @@
 import type { Plugin } from "rollup";
-export type XanixPluginOptions = {
-    mode: "watch" | "start";
-};
-export declare function XanixTransform(option: XanixPluginOptions): Plugin;
+export declare function XanixTransform(): Plugin;

package/dist/bin/bundler/plugins/XanixTransform/index.js

@@ -1,12 +1,12 @@
 import { transformer } from "./transformer.js";
-export function XanixTransform(option) {
+export function XanixTransform() {
     return {
         name: "xanix-transform",
         async transform(code, id) {
             if (id.includes("node_modules") || !/\.(tsx?|jsx?)$/.test(id)) {
                 return null;
             }
-            const result = transformer(code, id, option.mode);
+            const result = transformer(code, id);
             if (!result) {
                 return null;
             }

package/dist/bin/bundler/plugins/XanixTransform/transformer.d.ts

@@ -13,4 +13,4 @@ export declare function findComponentImport(ast: t.File, componentName: string):
     declaration: t.ImportDeclaration;
     specifier: t.ImportSpecifier | t.ImportDefaultSpecifier;
 } | null;
-export declare function transformer(code: string, id: string, mode: "watch" | "start"): XanixTransformResult | null;
+export declare function transformer(code: string, id: string): XanixTransformResult | null;

package/dist/bin/bundler/plugins/XanixTransform/transformer.js

@@ -309,109 +309,6 @@ function jsxToComponentAndProps(jsx) {
         props,
     };
 }
-/**
- * Find:
- *
- * const app = express();
- * const exp = express();
- * const server = express();
- *
- * Returns the variable name.
- */
-function findExpressAppVariable(ast) {
-    for (const statement of ast.program.body) {
-        if (!t.isVariableDeclaration(statement)) {
-            continue;
-        }
-        for (const declaration of statement.declarations) {
-            if (!t.isIdentifier(declaration.id)) {
-                continue;
-            }
-            if (!t.isCallExpression(declaration.init)) {
-                continue;
-            }
-            if (!t.isIdentifier(declaration.init.callee, {
-                name: "express",
-            })) {
-                continue;
-            }
-            return declaration.id.name;
-        }
-    }
-    return null;
-}
-/**
- * Replace:
- *
- * const app = express();
- *
- * with:
- *
- * const app = createXanixServer({
- *   mode: "watch"
- * });
- */
-function transformExpressAppTocreateXanixServer(ast, args) {
-    const expressVariable = findExpressAppVariable(ast);
-    if (!expressVariable) {
-        return false;
-    }
-    for (const statement of ast.program.body) {
-        if (!t.isVariableDeclaration(statement)) {
-            continue;
-        }
-        for (const declaration of statement.declarations) {
-            if (!t.isIdentifier(declaration.id)) {
-                continue;
-            }
-            if (declaration.id.name !== expressVariable) {
-                continue;
-            }
-            if (!t.isCallExpression(declaration.init)) {
-                continue;
-            }
-            if (!t.isIdentifier(declaration.init.callee, {
-                name: "express",
-            })) {
-                continue;
-            }
-            declaration.init = t.callExpression(t.identifier("createXanixServer"), [
-                t.objectExpression([
-                    t.objectProperty(t.identifier("mode"), t.stringLiteral(args.mode)),
-                ]),
-            ]);
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Remove:
- *
- * import express from "express";
- *
- * once express() has been replaced by
- * createXanixServer().
- *
- * Also handles:
- *
- * import express, { Router } from "express";
- */
-function removeExpressImport(ast) {
-    for (const statement of ast.program.body) {
-        if (!t.isImportDeclaration(statement)) {
-            continue;
-        }
-        if (statement.source.value !== "express") {
-            continue;
-        }
-        statement.specifiers = statement.specifiers.filter((specifier) => {
-            return !(t.isImportDefaultSpecifier(specifier) &&
-                specifier.local.name === "express");
-        });
-    }
-    removeEmptyImportDeclarations(ast);
-}
 function hasRuntimeImport(ast, name) {
     for (const statement of ast.program.body) {
         if (!t.isImportDeclaration(statement)) {
@@ -449,7 +346,7 @@ function injectRuntimeImport(ast, name) {
     // No runtime import exists yet
     ast.program.body.unshift(t.importDeclaration([t.importSpecifier(t.identifier(name), t.identifier(name))], t.stringLiteral(RUNTIME_IMPORT)));
 }
-export function transformer(code, id, mode) {
+export function transformer(code, id) {
     const ast = parse(code, {
         sourceType: "module",
         plugins: ["typescript", "jsx"],
@@ -586,33 +483,6 @@ export function transformer(code, id, mode) {
     if (!changed) {
         return null;
     }
-    /**
-     * Change:
-     *
-     * const app = express();
-     *
-     * into:
-     *
-     * const app = createXanixServer();
-     */
-    const serverTransformed = transformExpressAppTocreateXanixServer(ast, {
-        mode,
-    });
-    if (serverTransformed) {
-        /**
-         * Remove:
-         *
-         * import express from "express";
-         */
-        removeExpressImport(ast);
-        /**
-         * Add:
-         *
-         * import { createXanixServer }
-         *   from "xanix/runtime";
-         */
-        injectRuntimeImport(ast, "createXanixServer");
-    }
     /**
      * Add:
      *

package/dist/bin/bundler/plugins/plugins.js

@@ -6,10 +6,11 @@ import json from "@rollup/plugin-json";
 import esbuild from "rollup-plugin-esbuild";
 import url from "@rollup/plugin-url";
 import path from "path";
-import { XanixTransform } from "./XanixTransform/index.js";
+import XanixPageTransform from "./XanixPageTransform/index.js";
 import xanixReactRefresh from "./XanixReactRefresh.js";
 import XanixEnvPlugin from "./XanixEnv.js";
 import xanixUseDataId from "./xanixUseDataId.js";
+import XanixServerTransform from "./XanixServerTransform.js";
 export function xanixDefaultPlugins(options = {}) {
     const target = options.target ?? "client";
     const development = options.development ?? true;
@@ -17,8 +18,8 @@ export function xanixDefaultPlugins(options = {}) {
     const isServer = target === "server";
     let _plugins = [];
     if (isServer) {
-        _plugins.push(XanixTransform({ mode: development ? "watch" : "start" }));
-        // _plugins.push(XanixDocument());
+        _plugins.push(XanixPageTransform());
+        _plugins.push(XanixServerTransform({ mode: development ? "watch" : "start" }));
     }
     else {
         if (development) {

package/dist/bin/bundler/watchServer.js

@@ -32,7 +32,6 @@ const watchServer = async ({ rootEntry, onChange, onBuildEnd, onServerChange, on
                 assetExternal: false,
                 onChange: (entry) => {
                     changedFiles.add(entry);
-                    return onChange?.(entry);
                 },
             }),
         ],

package/dist/components/Head.js

@@ -6,7 +6,8 @@ const Head = ({ children }) => {
     const { title, meta, pageId, props, params, pageData } = useDocument();
     if (__XANIX_CLIENT__) {
         useEffect(() => {
-            document.title = title || "";
+            if (title)
+                document.title = title;
             meta?.forEach(({ name, content }) => {
                 let element = document.querySelector(`meta[name="${name}"]`);
                 if (!element) {
@@ -29,7 +30,7 @@ const Head = ({ children }) => {
         return null;
     }
     if (__XANIX_SERVER__) {
-        return (_jsxs("head", { children: [_jsx("title", { children: title }), meta?.map(({ name, content }) => (_jsx("meta", { name: name, content: content }, name))), children, _jsx("script", { id: pageId, dangerouslySetInnerHTML: {
+        return (_jsxs("head", { children: [title && _jsx("title", { children: title }), meta?.map(({ name, content }) => (_jsx("meta", { name: name, content: content }, name))), children, _jsx("script", { id: pageId, dangerouslySetInnerHTML: {
                         __html: `window.XANIX_DOCUMENT = ${JSON.stringify({
                             pageId,
                             props,

package/dist/server/runtime/createServer.js

@@ -28,7 +28,7 @@ function createXanixServer({ mode }) {
     });
     app.use((req, res, next) => {
         let data = {
-            title: null,
+            title: "",
             meta: [],
         };
         if (!req.page) {

package/dist/server/runtime/xanixPage.js

@@ -51,7 +51,7 @@ export default async function xanixPage({ pageId, req, res, Component, props, })
         renderToString(_jsx(Document, { document: {
                 pageId,
                 props,
-                title: title ?? entry.name.replaceAll("-", " "),
+                title,
                 meta,
                 params: req.params,
                 request: req,
@@ -64,7 +64,7 @@ export default async function xanixPage({ pageId, req, res, Component, props, })
         return JSON.stringify({
             pageId,
             props,
-            title: title ?? entry.name.replaceAll("-", " "),
+            title,
             meta,
             params: req.params,
             request: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xanix",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.js",