xanix 0.0.0 → 1.0.0

package/dist/client/refresh.js

@@ -0,0 +1,15 @@
+// refresh/index.ts
+import RefreshRuntime from "react-refresh";
+const runtime = RefreshRuntime;
+// if (typeof window !== "undefined") {
+//   RefreshRuntime.injectIntoGlobalHook(window);
+//   const win = window as any;
+//   win.$RefreshReg$ = () => {};
+//   win.$RefreshSig$ = () => (type: any) => type;
+// }
+export function register(component, id) {
+    runtime.register(component, id);
+}
+export function performRefresh() {
+    runtime.performReactRefresh();
+}

package/dist/client/runtime.d.ts

@@ -0,0 +1,10 @@
+import { DocumentContextData } from "../document/DocumentContext";
+import type { ComponentType } from "react";
+type DocumentInfo = DocumentContextData & {
+    component: ComponentType<any>;
+};
+export declare const getPath: () => string;
+export declare const getImportUrl: (pageId: string) => string;
+export declare const getPage: (path: string) => Promise<any>;
+export declare function mount(path: string, Component: ComponentType<any>, doc: DocumentInfo): Promise<void>;
+export {};

package/dist/client/runtime.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRoot } from "react-dom/client";
+const pages = new Map();
+const ROOT_KEY = "__xanix_root__";
+export const getPath = () => {
+    const { pathname, search } = window.location;
+    return search ? `${pathname}${search}` : pathname;
+};
+export const getImportUrl = (pageId) => `/.xanix/client/${pageId}.js`;
+function getRoot() {
+    let ele = document.body;
+    if (!ele) {
+        throw new Error("Root element not found");
+    }
+    ele[ROOT_KEY] = ele[ROOT_KEY] ?? createRoot(ele);
+    return ele[ROOT_KEY];
+}
+export const getPage = async (path) => {
+    let page = pages.get(path);
+    if (page)
+        return page;
+    const response = await fetch(path, {
+        headers: {
+            "X-Navigation": "true",
+        },
+    });
+    if (!response.ok) {
+        return null;
+    }
+    return await response.json();
+};
+export async function mount(path, Component, doc) {
+    const root = getRoot();
+    pages.set(path, doc);
+    const Document = (await import(getImportUrl("xanix-document"))).default;
+    root.render(_jsx(Document, { document: doc, children: _jsx(Component, { ...doc.props }) }));
+}
+if (typeof window !== "undefined") {
+    const dispatch = (name, path) => {
+        window.dispatchEvent(new CustomEvent(`xanix:${name}`, { detail: { path } }));
+    };
+    window.addEventListener("load", async () => {
+        const path = getPath();
+        dispatch("navigate:start", path);
+        const doc = window.XANIX_DOCUMENT;
+        const mod = await import(getImportUrl(doc.pageId));
+        mount(path, mod.default, doc);
+        const scriptTag = document.getElementById(doc.pageId);
+        if (scriptTag) {
+            scriptTag.remove();
+        }
+        dispatch("navigate:end", path);
+    });
+    window.addEventListener("xanix:navigate", async (event) => {
+        const path = event.detail.path;
+        const replace = event.detail.replace;
+        dispatch("navigate:start", path);
+        let page = await getPage(path);
+        if (!page)
+            return;
+        const mod = await import(getImportUrl(page.pageId));
+        mount(path, mod.default, page);
+        if (replace) {
+            history.replaceState(null, "", path);
+        }
+        else {
+            history.pushState(null, "", path);
+        }
+        dispatch("navigate:end", path);
+    });
+    window.addEventListener("xanix:preload", async (event) => {
+        const path = event.detail.path;
+        if (!path)
+            return;
+        dispatch("preload:start", path);
+        const page = await getPage(path);
+        if (!page)
+            return;
+        await import(getImportUrl(page.pageId));
+        pages.set(path, page);
+        dispatch("preload:end", path);
+    });
+    window.addEventListener("xanix:reload", async (event) => {
+        const path = getPath();
+        dispatch("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);
+    });
+    window.addEventListener("popstate", async () => {
+        const path = getPath();
+        dispatch("navigate", path);
+    });
+}

package/dist/client-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { DocumentContextData } from "./components/DocumentContext.js";
+import type { ComponentType } from "react";
+type DocumentInfo = DocumentContextData & {
+    component: ComponentType<any>;
+};
+export declare const getPath: () => string;
+export declare const getImportUrl: (pageId: string) => string;
+export declare const getPage: (path: string) => Promise<any>;
+export declare function mount(path: string, Component: ComponentType<any>, doc: DocumentInfo): Promise<void>;
+export {};

package/dist/client-runtime.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRoot } from "react-dom/client";
+const pages = new Map();
+const ROOT_KEY = "__xanix_root__";
+export const getPath = () => {
+    const { pathname, search } = window.location;
+    return search ? `${pathname}${search}` : pathname;
+};
+export const getImportUrl = (pageId) => `/.xanix/client/${pageId}.js`;
+function getRoot() {
+    let ele = document.body;
+    if (!ele) {
+        throw new Error("Root element not found");
+    }
+    ele[ROOT_KEY] = ele[ROOT_KEY] ?? createRoot(ele);
+    return ele[ROOT_KEY];
+}
+export const getPage = async (path) => {
+    let page = pages.get(path);
+    if (page)
+        return page;
+    const response = await fetch(path, {
+        headers: {
+            "X-Navigation": "true",
+        },
+    });
+    try {
+        const page = await response.json();
+        if (!page)
+            return null;
+        if (page.pageId && page.props && page.meta && page.params) {
+            return page;
+        }
+        throw new Error("Invalid page structure");
+    }
+    catch (error) {
+        console.error("Failed to fetch page:", error);
+    }
+    return null;
+};
+export async function mount(path, Component, doc) {
+    const root = getRoot();
+    pages.set(path, doc);
+    const Document = (await import(getImportUrl("xanix-document"))).default;
+    root.render(_jsx(Document, { document: doc, children: _jsx(Component, { ...doc.props }) }));
+}
+if (typeof window !== "undefined") {
+    const dispatch = (name, path) => {
+        window.dispatchEvent(new CustomEvent(`xanix:${name}`, { detail: { path } }));
+    };
+    window.addEventListener("load", async () => {
+        const path = getPath();
+        dispatch("navigate:start", path);
+        const doc = window.XANIX_DOCUMENT;
+        const mod = await import(getImportUrl(doc.pageId));
+        mount(path, mod.default, doc);
+        const scriptTag = document.getElementById(doc.pageId);
+        if (scriptTag) {
+            scriptTag.remove();
+        }
+        dispatch("navigate:end", path);
+    });
+    window.addEventListener("popstate", async () => {
+        dispatch("navigate", getPath());
+    });
+    window.addEventListener("xanix:navigate", async (event) => {
+        const { path, replace } = event.detail;
+        const currentPath = getPath();
+        if (path === currentPath)
+            return;
+        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);
+        let page = await getPage(path);
+        if (!page)
+            return;
+        if (!isSamePath) {
+            const mod = await import(getImportUrl(page.pageId));
+            mount(path, mod.default, page);
+        }
+        dispatch("navigate:end", path);
+        if (replace) {
+            history.replaceState(null, "", path);
+        }
+        else {
+            history.pushState(null, "", path);
+        }
+    });
+    window.addEventListener("xanix:preload", async (event) => {
+        const path = event.detail.path;
+        if (!path)
+            return;
+        dispatch("preload:start", path);
+        const page = await getPage(path);
+        if (!page)
+            return;
+        await import(getImportUrl(page.pageId));
+        pages.set(path, page);
+        dispatch("preload:end", path);
+    });
+    window.addEventListener("xanix:reload", async (event) => {
+        const path = getPath();
+        dispatch("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);
+    });
+}

package/dist/components/BaseDocument.d.ts

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

package/dist/components/BaseDocument.js

@@ -0,0 +1,8 @@
+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";
+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 })] }));
+};
+export default BaseDocument;

package/dist/components/Body.d.ts

@@ -0,0 +1,5 @@
+type BodyProps = {
+    children?: React.ReactNode;
+};
+declare const Body: ({ children }: BodyProps) => string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+export default Body;

package/dist/components/Body.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const Body = ({ children }) => {
+    if (__XANIX_CLIENT__) {
+        return children;
+    }
+    return _jsx("body", { children: children });
+};
+export default Body;

package/dist/components/Document/Document.d.ts

@@ -0,0 +1,16 @@
+export type DocumentContextData = {
+    pageId?: string;
+    props: Record<string, any>;
+    title: string;
+    meta: Array<{
+        name: string;
+        content: string;
+    }>;
+};
+export declare const useDocument: () => DocumentContextData | null;
+export type DocumentProps = {
+    children?: React.ReactNode;
+    document: DocumentContextData;
+};
+declare const Document: ({ children, document }: DocumentProps) => import("react").JSX.Element;
+export default Document;

package/dist/components/Document/Document.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const DocumentContext = createContext(null);
+export const useDocument = () => {
+    return useContext(DocumentContext);
+};
+const DocumentProvider = DocumentContext.Provider;
+const Document = ({ children, document }) => {
+    const isClient = typeof window !== "undefined";
+    if (isClient) {
+        return _jsx(DocumentProvider, { value: document, children: children });
+    }
+    return (_jsx(DocumentProvider, { value: document, children: _jsx("html", { children: children }) }));
+};
+export default Document;

package/dist/components/Document/context.d.ts

@@ -0,0 +1,17 @@
+export type DocumentContextData = {
+    pageId: string;
+    props: Record<string, any>;
+    title: string;
+    meta: Array<{
+        name: string;
+        content: string;
+    }>;
+    request?: Express.Request;
+};
+export declare const DocumentContext: import("react").Context<DocumentContextData | null>;
+export declare const useDocument: () => DocumentContextData;
+export type DocumentProviderProps = {
+    children: React.ReactNode;
+    value: DocumentContextData;
+};
+export declare const DocumentProvider: ({ children, value, }: DocumentProviderProps) => import("react").JSX.Element;

package/dist/components/Document/context.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+export const DocumentContext = createContext(null);
+export const useDocument = () => {
+    const context = useContext(DocumentContext);
+    if (!context) {
+        throw new Error("useDocument must be used within a DocumentProvider");
+    }
+    return context;
+};
+export const DocumentProvider = ({ children, value, }) => {
+    return (_jsx(DocumentContext.Provider, { value: value, children: children }));
+};

package/dist/components/Document/index.d.ts

@@ -0,0 +1,7 @@
+import { DocumentContextData } from "./context.js";
+export type DocumentProps = {
+    children?: React.ReactNode;
+    document: DocumentContextData;
+};
+declare const Document: ({ children, document }: DocumentProps) => import("react").JSX.Element;
+export default Document;

package/dist/components/Document/index.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DocumentProvider } from "./context.js";
+const Document = ({ children, document }) => {
+    const isClient = typeof window !== "undefined";
+    if (isClient) {
+        return _jsx(DocumentProvider, { value: document, children: children });
+    }
+    return (_jsx(DocumentProvider, { value: document, children: _jsx("html", { children: children }) }));
+};
+export default Document;

package/dist/components/Document.d.ts

@@ -0,0 +1,7 @@
+import { DocumentContextData } from "./DocumentContext.js";
+export type DocumentProps = {
+    children?: React.ReactNode;
+    document: DocumentContextData;
+};
+declare const Document: ({ children, document }: DocumentProps) => import("react").JSX.Element;
+export default Document;

package/dist/components/Document.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DocumentProvider } from "./DocumentContext.js";
+const Document = ({ children, document }) => {
+    if (__XANIX_CLIENT__) {
+        return _jsx(DocumentProvider, { value: document, children: children });
+    }
+    return (_jsx(DocumentProvider, { value: document, children: _jsx("html", { children: children }) }));
+};
+export default Document;

package/dist/components/DocumentContext/DocumentContext.d.ts

@@ -0,0 +1,15 @@
+export type XanixDocumentData = {
+    pageId?: string;
+    props: Record<string, any>;
+    title: string;
+    meta: Array<{
+        name: string;
+        content: string;
+    }>;
+};
+export declare const DocumentContext: import("react").Context<XanixDocumentData>;
+export declare const useDocument: () => XanixDocumentData;
+export declare const DocumentProvider: ({ children, value, }: {
+    children: React.ReactNode;
+    value: XanixDocumentData;
+}) => import("react").JSX.Element;

package/dist/components/DocumentContext/DocumentContext.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+export const DocumentContext = createContext({
+    pageId: "",
+    title: "",
+    props: {},
+    meta: [],
+});
+export const useDocument = () => {
+    const context = useContext(DocumentContext);
+    if (!context) {
+        throw new Error("useDocument must be used within a DocumentProvider");
+    }
+    return context;
+};
+export const DocumentProvider = ({ children, value, }) => {
+    return (_jsx(DocumentContext.Provider, { value: value, children: children }));
+};

package/dist/components/DocumentContext/context.d.ts

@@ -0,0 +1,11 @@
+export type XanixDocumentData = {
+    pageId?: string;
+    props: Record<string, any>;
+    title: string;
+    meta: Array<{
+        name: string;
+        content: string;
+    }>;
+};
+export declare const DocumentContext: import("react").Context<XanixDocumentData>;
+export declare const useDocument: () => XanixDocumentData;

package/dist/components/DocumentContext/context.js

@@ -0,0 +1,14 @@
+import { createContext, useContext } from "react";
+export const DocumentContext = createContext({
+    pageId: "",
+    title: "",
+    props: {},
+    meta: [],
+});
+export const useDocument = () => {
+    const context = useContext(DocumentContext);
+    if (!context) {
+        throw new Error("useDocument must be used within a DocumentProvider");
+    }
+    return context;
+};

package/dist/components/DocumentContext/index.d.ts

@@ -0,0 +1,15 @@
+export type XanixDocumentData = {
+    pageId?: string;
+    props: Record<string, any>;
+    title: string;
+    meta: Array<{
+        name: string;
+        content: string;
+    }>;
+};
+export declare const DocumentContext: import("react").Context<XanixDocumentData>;
+export declare const useDocument: () => XanixDocumentData;
+export declare const DocumentProvider: ({ children, value, }: {
+    children: React.ReactNode;
+    value: XanixDocumentData;
+}) => import("react").JSX.Element;

package/dist/components/DocumentContext/index.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+export const DocumentContext = createContext({
+    pageId: "",
+    title: "",
+    props: {},
+    meta: [],
+});
+export const useDocument = () => {
+    const context = useContext(DocumentContext);
+    if (!context) {
+        throw new Error("useDocument must be used within a DocumentProvider");
+    }
+    return context;
+};
+export const DocumentProvider = ({ children, value, }) => {
+    return (_jsx(DocumentContext.Provider, { value: value, children: children }));
+};

package/dist/components/DocumentContext.d.ts

@@ -0,0 +1,19 @@
+import type { Request } from "express";
+export type DocumentContextData = {
+    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 declare const DocumentContext: import("react").Context<DocumentContextData | null>;
+export type DocumentProviderProps = {
+    children: React.ReactNode;
+    value: DocumentContextData;
+};
+export declare const DocumentProvider: ({ children, value, }: DocumentProviderProps) => import("react").JSX.Element;

package/dist/components/DocumentContext.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext } from "react";
+export const DocumentContext = createContext(null);
+export const DocumentProvider = ({ children, value, }) => {
+    return (_jsx(DocumentContext.Provider, { value: value, children: children }));
+};

package/dist/components/DocumentProvider.d.ts

@@ -0,0 +1,13 @@
+export type DocumentContextData = {
+    pageId?: string;
+    props: Record<string, any>;
+    title: string;
+    meta: Array<{
+        name: string;
+        content: string;
+    }>;
+};
+export declare const DocumentContext: import("react").Context<DocumentContextData | null>;
+export declare const useDocument: () => DocumentContextData | null;
+declare const DocumentProvider: import("react").Provider<DocumentContextData | null>;
+export default DocumentProvider;

package/dist/components/DocumentProvider.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from "react";
+export const DocumentContext = createContext(null);
+export const useDocument = () => {
+    return useContext(DocumentContext);
+};
+const DocumentProvider = DocumentContext.Provider;
+export default DocumentProvider;

package/dist/components/Head.d.ts

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

package/dist/components/Head.js

@@ -0,0 +1,42 @@
+import { Fragment as _Fragment, 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);
+            });
+        }
+    }, [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,
+                    })};
+        `,
+                } }), _jsx("script", { type: "module", src: `/.xanix/client/xanix-runtime.js` })] }));
+};
+export default Head;

package/dist/components/Link.d.ts

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

package/dist/components/Link.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+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 (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 }));
+};
+export default Link;

package/dist/components/Script.d.ts

@@ -0,0 +1,3 @@
+type ScriptProps = React.DetailedHTMLProps<React.ScriptHTMLAttributes<HTMLScriptElement>, HTMLScriptElement>;
+declare const Script: ({ children, ...props }: ScriptProps) => import("react").JSX.Element;
+export default Script;

package/dist/components/Script.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const Script = ({ children, ...props }) => {
+    return _jsx("script", { ...props, children: children });
+};
+export default Script;

package/dist/dataLoader.d.ts

@@ -0,0 +1,11 @@
+type PageId = string;
+type Callback = (args: Record<string, any>) => Promise<any>;
+type XanixId = string;
+declare const dataLoader: {
+    results: (pageId: PageId) => Promise<Record<string, any>>;
+    result: (xanixId: XanixId, args?: Record<string, any>) => Promise<any>;
+    isInit: (pageId: PageId) => any;
+    register: (xanixId: XanixId, callback: Callback) => string;
+    registerPage: (pageId: PageId, xanixId: XanixId, args: Record<string, any>) => string;
+};
+export default dataLoader;