xanix 1.0.4 → 1.0.7

package/dist/bin/cli/dev.js

@@ -11,7 +11,7 @@ const root = process.cwd();
 let child;
 function start() {
     child?.kill();
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
         const filePath = path.join(outDir.server, "index.js");
         child = spawn(process.execPath, [filePath], {
             stdio: !child ? "inherit" : "pipe",
@@ -78,7 +78,7 @@ const dev = async (rootEntry) => {
         async onClientEntryChange(_entry, entries) {
             await clientWatcher(entries);
         },
-        onServerChange: async (entry, entries) => {
+        onServerChange: async (_entry, _entries) => {
             await start();
         },
         onBuildEnd: async () => {

package/dist/bin/include/utils.d.ts

@@ -1,2 +1,5 @@
+export declare function uid(value: string, length?: number): string;
 export declare const getClientRuntimeFile: () => string;
+export declare const getClientRuntimeFileName: (mode: "development" | "production") => string;
 export declare const getDocumentFile: () => Promise<string>;
+export declare const getDocumentFileName: (mode: "development" | "production") => string;

package/dist/bin/include/utils.js

@@ -1,10 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import crypto from "node:crypto";
 const __dirname = fileURLToPath(import.meta.url);
+export function uid(value, length) {
+    const hash = crypto.createHash("sha256").update(value).digest("hex");
+    return length ? hash.slice(0, length) : hash;
+}
 export const getClientRuntimeFile = () => {
     return path.join(__dirname, "../../../client-runtime.js");
 };
+export const getClientRuntimeFileName = (mode) => {
+    if (mode === "development") {
+        return "xanix-runtime";
+    }
+    return uid("xanix-runtime", 32);
+};
 export const getDocumentFile = async () => {
     const documentEntry = path.join(process.cwd(), "Document.tsx");
     if (fs.existsSync(documentEntry)) {
@@ -12,3 +23,9 @@ export const getDocumentFile = async () => {
     }
     return path.join(__dirname, "../../../components/BaseDocument.js");
 };
+export const getDocumentFileName = (mode) => {
+    if (mode === "development") {
+        return "xanix-documents";
+    }
+    return uid("xanix-document", 32);
+};

package/dist/client-runtime.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createRoot } from "react-dom/client";
+import Document from "virtual:xanix-document";
 const pages = new Map();
 const ROOT_KEY = "__xanix_root__";
 export const getPath = () => {
@@ -41,16 +42,17 @@ export const getPage = async (path) => {
 export async function mount(path, Component, doc) {
     const root = getRoot();
     pages.set(path, doc);
-    const Document = (await import(getImportUrl("xanix-document"))).default;
+    // const Document = (await import(getImportUrl(__XANIX_DOCUMENT_FILE_NAME__)))
+    //   .default;
     root.render(_jsx(Document, { document: doc, children: _jsx(Component, { ...doc.props }) }));
 }
-if (typeof window !== "undefined") {
+if (__XANIX_CLIENT__) {
     const dispatch = (name, path) => {
-        window.dispatchEvent(new CustomEvent(`xanix:${name}`, { detail: { path } }));
+        window.dispatchEvent(new CustomEvent(name, { detail: { path } }));
     };
     window.addEventListener("load", async () => {
         const path = getPath();
-        dispatch("navigate:start", path);
+        dispatch(XANIX_NAVIGATE_START, path);
         const doc = window.XANIX_DOCUMENT;
         const mod = await import(getImportUrl(doc.pageId));
         mount(path, mod.default, doc);
@@ -58,12 +60,12 @@ if (typeof window !== "undefined") {
         if (scriptTag) {
             scriptTag.remove();
         }
-        dispatch("navigate:end", path);
+        dispatch(XANIX_NAVIGATE_END, path);
     });
     window.addEventListener("popstate", async () => {
-        dispatch("navigate", getPath());
+        dispatch(XANIX_NAVIGATE, getPath());
     });
-    window.addEventListener("xanix:navigate", async (event) => {
+    window.addEventListener(XANIX_NAVIGATE, async (event) => {
         const { path, replace } = event.detail;
         const currentPath = getPath();
         if (path === currentPath)
@@ -71,7 +73,7 @@ if (typeof window !== "undefined") {
         const url = new URL(path, window.location.origin);
         const prevUrl = new URL(currentPath, window.location.origin);
         const isSamePath = url.pathname === prevUrl.pathname;
-        dispatch("navigate:start", path);
+        dispatch(XANIX_NAVIGATE_START, path);
         let page = await getPage(path);
         if (!page)
             return;
@@ -79,7 +81,7 @@ if (typeof window !== "undefined") {
             const mod = await import(getImportUrl(page.pageId));
             mount(path, mod.default, page);
         }
-        dispatch("navigate:end", path);
+        dispatch(XANIX_NAVIGATE_END, path);
         if (replace) {
             history.replaceState(null, "", path);
         }
@@ -87,27 +89,27 @@ if (typeof window !== "undefined") {
             history.pushState(null, "", path);
         }
     });
-    window.addEventListener("xanix:preload", async (event) => {
+    window.addEventListener(XANIX_PRELOAD, async (event) => {
         const path = event.detail.path;
         if (!path)
             return;
-        dispatch("preload:start", path);
+        dispatch(XANIX_PRELOAD_START, path);
         const page = await getPage(path);
         if (!page)
             return;
         await import(getImportUrl(page.pageId));
         pages.set(path, page);
-        dispatch("preload:end", path);
+        dispatch(XANIX_PRELOAD_END, path);
     });
-    window.addEventListener("xanix:reload", async (event) => {
+    window.addEventListener(XANIX_NAVIGATE_RELOAD, async (event) => {
         const path = getPath();
-        dispatch("navigate:start", path);
+        dispatch(XANIX_NAVIGATE_START, path);
         let page = await getPage(path);
         if (!page)
             return;
         const mod = await import(getImportUrl(page.pageId) + "?t=" + Date.now());
         mount(path, mod.default, page);
         history.pushState(null, "", path);
-        dispatch("navigate:end", path);
+        dispatch(XANIX_NAVIGATE_END, path);
     });
 }

package/dist/components/BaseDocument.d.ts

@@ -1,3 +1,3 @@
-import { DocumentProps } from "./Document.js";
+import { type DocumentProps } from "../index.js";
 declare const BaseDocument: ({ document, children }: DocumentProps) => import("react").JSX.Element;
 export default BaseDocument;

package/dist/components/BaseDocument.js

@@ -1,7 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import Head from "./Head.js";
-import Body from "./Body.js";
-import Document from "./Document.js";
+import { Head, Body, Document } from "../index.js";
 const BaseDocument = ({ document, children }) => {
     return (_jsxs(Document, { document: document, children: [_jsxs(Head, { children: [_jsx("meta", { charSet: "UTF-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" })] }), _jsx(Body, { children: children })] }));
 };

package/dist/components/Body.js

@@ -3,6 +3,8 @@ const Body = ({ children }) => {
     if (__XANIX_CLIENT__) {
         return children;
     }
-    return _jsx("body", { children: children });
+    else {
+        return _jsx("body", { children: children });
+    }
 };
 export default Body;

package/dist/components/Document.js

@@ -4,6 +4,8 @@ const Document = ({ children, document }) => {
     if (__XANIX_CLIENT__) {
         return _jsx(DocumentProvider, { value: document, children: children });
     }
-    return (_jsx(DocumentProvider, { value: document, children: _jsx("html", { children: children }) }));
+    else {
+        return (_jsx(DocumentProvider, { value: document, children: _jsx("html", { children: children }) }));
+    }
 };
 export default Document;

package/dist/components/Head.d.ts

@@ -1,5 +1,5 @@
 type HeadProps = {
     children?: React.ReactNode;
 };
-declare const Head: ({ children }: HeadProps) => import("react").JSX.Element;
+declare const Head: ({ children }: HeadProps) => import("react").JSX.Element | null | undefined;
 export default Head;

package/dist/components/Head.js

@@ -1,42 +1,45 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect } from "react";
 import useDocument from "../hooks/useDocument.js";
 const Head = ({ children }) => {
     const { title, meta, pageId, props, params, pageData } = useDocument();
-    useEffect(() => {
-        document.title = title || "";
-        meta?.forEach(({ name, content }) => {
-            let element = document.querySelector(`meta[name="${name}"]`);
-            if (!element) {
-                element = document.createElement("meta");
-                element.setAttribute("name", name);
-                document.head.appendChild(element);
-            }
-            element.setAttribute("content", content);
-        });
-        // add children
-        const head = document.head;
-        if (children) {
-            const container = document.createElement("div");
-            container.innerHTML = children;
-            Array.from(container.children).forEach((child) => {
-                head.appendChild(child);
+    if (__XANIX_CLIENT__) {
+        useEffect(() => {
+            document.title = title || "";
+            meta?.forEach(({ name, content }) => {
+                let element = document.querySelector(`meta[name="${name}"]`);
+                if (!element) {
+                    element = document.createElement("meta");
+                    element.setAttribute("name", name);
+                    document.head.appendChild(element);
+                }
+                element.setAttribute("content", content);
             });
-        }
-    }, [children]);
-    if (__XANIX_CLIENT__)
-        return _jsx(_Fragment, {});
-    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: {
-                    __html: `window.XANIX_DOCUMENT = ${JSON.stringify({
-                        pageId,
-                        props,
-                        meta,
-                        title,
-                        params,
-                        pageData,
-                        request: null,
-                    })};
+            // add children
+            const head = document.head;
+            if (children) {
+                const container = document.createElement("div");
+                container.innerHTML = children;
+                Array.from(container.children).forEach((child) => {
+                    head.appendChild(child);
+                });
+            }
+        }, [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: {
+                        __html: `window.XANIX_DOCUMENT = ${JSON.stringify({
+                            pageId,
+                            props,
+                            meta,
+                            title,
+                            params,
+                            pageData,
+                            request: null,
+                        })};
         `,
-                } }), _jsx("script", { type: "module", src: `/.xanix/client/xanix-runtime.js` })] }));
+                    } }), _jsx("script", { type: "module", src: `/.xanix/client/${__XANIX_CLIENT_RUNTIME_FILE_NAME__}.js` })] }));
+    }
 };
 export default Head;

package/dist/components/Link.d.ts

@@ -3,5 +3,5 @@ export type LinkProps = Omit<HTMLProps<HTMLAnchorElement>, "href" | "preload"> &
     preload?: boolean;
     href: string;
 };
-declare const Link: ({ children, preload, ...props }: LinkProps) => import("react").JSX.Element;
+declare const Link: ({ children, preload, ...props }: LinkProps) => import("react").JSX.Element | undefined;
 export default Link;

package/dist/components/Link.js

@@ -3,26 +3,31 @@ import { useEffect, useRef } from "react";
 import { navigate } from "../navigate.js";
 const Link = ({ children, preload, ...props }) => {
     const ref = useRef(null);
-    useEffect(() => {
-        const load = () => {
-            window.dispatchEvent(new CustomEvent("xanix:preload", { detail: { path: props.href } }));
-        };
-        if (preload && ref.current) {
-            ref.current.addEventListener("mouseenter", load);
-        }
-        return () => {
+    if (__XANIX_CLIENT__) {
+        useEffect(() => {
+            const load = () => {
+                window.dispatchEvent(new CustomEvent("xanix:preload", { detail: { path: props.href } }));
+            };
             if (preload && ref.current) {
-                ref.current.removeEventListener("mouseenter", load);
+                ref.current.addEventListener("mouseenter", load);
             }
-        };
-    }, []);
-    if (preload) {
-        props.onMouseEnter;
+            return () => {
+                if (preload && ref.current) {
+                    ref.current.removeEventListener("mouseenter", load);
+                }
+            };
+        }, []);
+        if (preload) {
+            props.onMouseEnter;
+        }
+        return (_jsx("a", { ref: ref, ...props, onClick: (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                navigate(props.href);
+            }, children: children }));
+    }
+    if (__XANIX_SERVER__) {
+        return _jsx("a", { ...props, children: children });
     }
-    return (_jsx("a", { ref: ref, ...props, onClick: (e) => {
-            e.preventDefault();
-            e.stopPropagation();
-            navigate(props.href);
-        }, children: children }));
 };
 export default Link;

package/dist/dataLoader.d.ts

@@ -2,7 +2,7 @@ type PageId = string;
 type Callback = (args: Record<string, any>) => Promise<any>;
 type XanixId = string;
 declare const dataLoader: {
-    results: (pageId: PageId) => Promise<Record<string, any>>;
+    results: (pageId: PageId) => Promise<any>;
     result: (xanixId: XanixId, args?: Record<string, any>) => Promise<any>;
     isInit: (pageId: PageId) => any;
     register: (xanixId: XanixId, callback: Callback) => string;

package/dist/dataLoader.js

@@ -1,4 +1,8 @@
-let global = typeof window === "undefined" ? globalThis : window;
+let global = typeof __XANIX_SERVER__ !== "undefined" && __XANIX_SERVER__
+    ? globalThis
+    : typeof window !== "undefined"
+        ? window
+        : {};
 global.$XANIXDT_INITIALED = new Map();
 global.$XANIXDT = new Map();
 global.$XANIXDT_PAGES = new Map();
@@ -15,14 +19,19 @@ const registerPage = (pageId, xanixId, args) => {
     return xanixId;
 };
 const results = async (pageId) => {
-    global.$XANIXDT_INITIALED.set(pageId, true);
+    if (global.$XANIXDT_INITIALED.has(pageId)) {
+        return global.$XANIXDT_INITIALED.get(pageId);
+    }
     const page = global.$XANIXDT_PAGES.get(pageId) || [];
     const datas = {};
     await Promise.all(page.map(async (xanixId) => {
-        const { callback, args } = global.$XANIXDT.get(xanixId);
-        const data = await callback(args);
-        datas[xanixId] = data;
+        const item = global.$XANIXDT.get(xanixId);
+        if (!item)
+            return;
+        const { callback, args } = item;
+        datas[xanixId] = await callback(args);
     }));
+    global.$XANIXDT_INITIALED.set(pageId, datas);
     return datas;
 };
 const result = async (xanixId, args) => {

package/dist/hooks/useData.d.ts

@@ -5,14 +5,10 @@ declare const useData: {
         loading: boolean;
         reload: () => Promise<void>;
     };
-    register(xanixId: string, callback: Callback): ((args?: Record<string, any>) => Promise<{
+    register(xanixId: string, callback: Callback): (args?: Record<string, any>) => {
         data: any;
         loading: boolean;
         reload: () => Promise<void>;
-    }>) | ((args?: Record<string, any>) => {
-        data: any;
-        loading: boolean;
-        reload: () => Promise<void>;
-    });
+    };
 };
 export default useData;

package/dist/hooks/useData.js

@@ -8,7 +8,7 @@ const useData = (_callback, _args) => {
 useData.register = (xanixId, callback) => {
     if (typeof __XANIX_SERVER__ !== "undefined" && __XANIX_SERVER__) {
         loader.register(xanixId, callback);
-        return async (args) => {
+        return (args) => {
             const page = usePage();
             const doc = useDocument();
             loader.registerPage(page.pageId, xanixId, args ?? {});

package/dist/index.d.ts

@@ -1,3 +1,7 @@
+/// <reference path="./types/globals.d.ts" />
+/// <reference path="./types/express.d.ts" />
+/// <reference path="./types/assets.d.ts" />
+
 import Link from "./components/Link.js";
 import Document, { DocumentProps } from "./components/Document.js";
 import Head from "./components/Head.js";

package/dist/index.js

@@ -1,3 +1,6 @@
+/// <reference path="./types/globals.d.ts" />
+/// <reference path="./types/express.d.ts" />
+/// <reference path="./types/assets.d.ts" />
 import Link from "./components/Link.js";
 import Document from "./components/Document.js";
 import Head from "./components/Head.js";

package/dist/navigate.js

@@ -1,5 +1,5 @@
 export const navigate = (path, replace = false) => {
-    window.dispatchEvent(new CustomEvent("xanix:navigate", {
+    window.dispatchEvent(new CustomEvent(XANIX_NAVIGATE, {
         detail: { path, replace },
     }));
 };
@@ -10,22 +10,25 @@ export const forward = () => {
     window.history.forward();
 };
 export const preload = async (path) => {
-    window.dispatchEvent(new CustomEvent("xanix:preload", { detail: { path } }));
+    window.dispatchEvent(new CustomEvent(XANIX_PRELOAD, { detail: { path } }));
 };
 export const reload = (hard = false) => {
-    if (hard) {
-        window.location.reload();
-        return;
+    if (__XANIX_CLIENT__) {
+        if (hard) {
+            window.location.reload();
+        }
+        else {
+            window.dispatchEvent(new CustomEvent(XANIX_NAVIGATE_RELOAD));
+        }
     }
-    window.dispatchEvent(new CustomEvent("xanix:reload"));
 };
 export const onNavigateStart = (callback) => {
     if (__XANIX_CLIENT__) {
-        window.addEventListener("xanix:navigate:start", callback);
+        window.addEventListener(XANIX_NAVIGATE_START, callback);
     }
 };
 export const onNavigateEnd = (callback) => {
     if (__XANIX_CLIENT__) {
-        window.addEventListener("xanix:navigate:end", callback);
+        window.addEventListener(XANIX_NAVIGATE_END, callback);
     }
 };

package/dist/server/runtime/xanixPage.js

@@ -2,9 +2,8 @@ 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";
+import Document from "virtual:xanix-document";
 function renderPage(element) {
     return new Promise((resolve, reject) => {
         let html = "";
@@ -48,8 +47,6 @@ export default async function xanixPage({ pageId, req, res, Component, props, })
         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,

package/dist/types/assets.d.ts

@@ -0,0 +1,34 @@
+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 "*.css" {
+  const src: string;
+  export default src;
+}

package/dist/types/express.d.ts

@@ -0,0 +1,12 @@
+import "express-serve-static-core";
+
+declare module "express-serve-static-core" {
+  interface Request {
+    page: {
+      setTitle(title: string): void;
+      setMeta(name: string, content: string): void;
+    };
+  }
+}
+
+export {};

package/dist/types/globals.d.ts

@@ -0,0 +1,27 @@
+declare global {
+  const __XANIX_CLIENT_RUNTIME_FILE_NAME__: string;
+  const __XANIX_DOCUMENT_FILE_NAME__: string;
+  const __XANIX_CLIENT__: boolean;
+  const __XANIX_SERVER__: boolean;
+  const __XANIX_DEV__: boolean;
+  const __XANIX_PROD__: boolean;
+
+  // XANIX Data
+  const XANIXDT: {
+    handlers: Record<string, () => Promise<any>>;
+    pages: Record<string, string[]>;
+    initialed: Record<string, boolean>;
+  };
+
+  // navigation events
+  const XANIX_NAVIGATE: string;
+  const XANIX_NAVIGATE_START: string;
+  const XANIX_NAVIGATE_END: string;
+  const XANIX_PRELOAD: string;
+  const XANIX_PRELOAD_START: string;
+  const XANIX_PRELOAD_END: string;
+
+  const XANIX_NAVIGATE_RELOAD: string;
+}
+
+export {};

package/dist/types/xanix-virtual.d.ts

@@ -0,0 +1,26 @@
+declare module "virtual:xanix-document" {
+  import type { ComponentType, ReactNode } from "react";
+  import type { Request } from "express";
+
+  export type XanixDocumentData = {
+    pageId: string;
+    props: Record<string, any>;
+    title: string;
+    meta: Array<{
+      name: string;
+      content: string;
+    }>;
+    params: Record<string, string>;
+    request?: Request;
+    pageData: Record<string, any>;
+  };
+
+  export type XanixDocumentProps = {
+    document: XanixDocumentData;
+    children?: ReactNode;
+  };
+
+  const Document: ComponentType<XanixDocumentProps>;
+
+  export default Document;
+}