xanix 0.0.0 → 1.0.0

package/dist/bin/bundler/watchClient.js

@@ -0,0 +1,54 @@
+import { watch } from "rollup";
+import bundlerOutput, { outDir } from "./config/output.js";
+import fs from "node:fs";
+import BuildCache from "./cacheNpmModules.js";
+import XanixResolveCacheDeps from "./plugins/XanixResolveCacheDeps/index.js";
+import { getDocumentFile, getClientRuntimeFile } from "../include/utils.js";
+import { xanixDefaultPlugins } from "./plugins/plugins.js";
+const WatchClient = async (entries, options) => {
+    const input = {};
+    for (const entry of entries) {
+        input[entry.name] = entry.file;
+    }
+    input["xanix-runtime"] = getClientRuntimeFile();
+    input["xanix-document"] = await getDocumentFile();
+    fs.rmSync(outDir.client, {
+        recursive: true,
+        force: true,
+    });
+    fs.mkdirSync(outDir.client, {
+        recursive: true,
+    });
+    const buildCache = await BuildCache(entries);
+    const watcher = watch({
+        input,
+        treeshake: true,
+        plugins: [
+            XanixResolveCacheDeps(buildCache, entries),
+            ...xanixDefaultPlugins({
+                target: "client",
+                development: true,
+                assetExternal: true,
+                onChange: options.onChange,
+            }),
+        ],
+        output: bundlerOutput.client(entries, { isDev: true }),
+        watch: {
+            clearScreen: false,
+        },
+    });
+    watcher.on("event", (event) => {
+        switch (event.code) {
+            case "BUNDLE_START":
+                break;
+            case "BUNDLE_END":
+                options.onBuildEnd?.();
+                break;
+            case "ERROR":
+                console.error("[client]", event.error);
+                break;
+        }
+    });
+    return watcher;
+};
+export default WatchClient;

package/dist/bin/bundler/watchServer.d.ts

@@ -0,0 +1,10 @@
+import { XanixClientEntry } from "../types.js";
+export type WatcherOptions = {
+    rootEntry: string;
+    onChange?: (id: string) => Promise<void>;
+    onBuildEnd?: (entries: XanixClientEntry[]) => Promise<void>;
+    onClientEntryChange: (id: string, entries: XanixClientEntry[]) => Promise<void>;
+    onServerChange?: (id: string, entries: XanixClientEntry[]) => Promise<void>;
+};
+declare const watchServer: ({ rootEntry, onChange, onBuildEnd, onServerChange, onClientEntryChange, }: WatcherOptions) => Promise<import("rollup").RollupWatcher>;
+export default watchServer;

package/dist/bin/bundler/watchServer.js

@@ -0,0 +1,84 @@
+import { watch } from "rollup";
+import path from "node:path";
+import fs from "node:fs";
+import { createManifest, readManifest } from "../include/manifest.js";
+import generateClientEntries from "./generateClientEntries.js";
+import bundlerOutput, { outDir } from "./config/output.js";
+import { getDocumentFile } from "../include/utils.js";
+import { entriesEqual } from "../include/entry.js";
+import { xanixDefaultPlugins } from "./plugins/plugins.js";
+const root = process.cwd();
+const watchServer = async ({ rootEntry, onChange, onBuildEnd, onServerChange, onClientEntryChange, }) => {
+    fs.rmSync(outDir.server, {
+        recursive: true,
+        force: true,
+    });
+    fs.mkdirSync(outDir.server, {
+        recursive: true,
+    });
+    const entries = await generateClientEntries();
+    await createManifest(entries);
+    const input = {
+        index: path.resolve(root, rootEntry),
+        "xanix-document": await getDocumentFile(),
+    };
+    const changedFiles = new Set();
+    const watcher = watch({
+        input,
+        treeshake: true,
+        plugins: [
+            ...xanixDefaultPlugins({
+                target: "server",
+                development: true,
+                assetExternal: false,
+                onChange: onChange,
+            }),
+        ],
+        external(id) {
+            if (id.startsWith(".") ||
+                path.isAbsolute(id) ||
+                id === "@" ||
+                id.startsWith("@/")) {
+                return false;
+            }
+            return true;
+        },
+        output: bundlerOutput.server(),
+        watch: {
+            clearScreen: false,
+        },
+    });
+    watcher.on("event", async (event) => {
+        switch (event.code) {
+            case "BUNDLE_START":
+                break;
+            case "BUNDLE_END":
+                if (changedFiles.size) {
+                    const manifest = await readManifest();
+                    if (manifest) {
+                        for (const entry of changedFiles) {
+                            const isClientEntry = Array.from(manifest.entries.values()).find((e) => e.file === entry);
+                            if (!isClientEntry) {
+                                const entries = await generateClientEntries();
+                                const isEqual = await entriesEqual(entries);
+                                if (!isEqual) {
+                                    await createManifest(entries);
+                                    await onClientEntryChange?.(entry, entries);
+                                }
+                                await onServerChange?.(entry, entries);
+                            }
+                            await onChange?.(entry);
+                        }
+                    }
+                    changedFiles.clear();
+                }
+                await onBuildEnd?.(entries);
+                break;
+            case "ERROR":
+                console.error("[server]", event.error);
+                break;
+        }
+    });
+    return watcher;
+};
+export default watchServer;

package/dist/bin/cli/build.d.ts

@@ -0,0 +1,2 @@
+declare const build: (rootEntry: string) => Promise<void>;
+export default build;

package/dist/bin/cli/build.js

@@ -0,0 +1,18 @@
+import buildServer from "../bundler/buildServer.js";
+import buildClient from "../bundler/buildClient.js";
+import pc from "picocolors";
+import logger from "../include/logger.js";
+const build = async (rootEntry) => {
+    logger.info(pc.green("Building server..."), "server");
+    const st = Date.now();
+    await buildServer({
+        rootEntry,
+        onBuildEnd: async (entries) => {
+            logger.info(pc.green("Building client..."), "client");
+            const duration = Date.now() - st;
+            await buildClient(entries);
+            logger.info(pc.green(`Build completed in ${duration}ms`), "complete");
+        },
+    });
+};
+export default build;

package/dist/bin/cli/dev.d.ts

@@ -0,0 +1,2 @@
+declare const dev: (rootEntry: string) => Promise<void>;
+export default dev;

package/dist/bin/cli/dev.js

@@ -0,0 +1,103 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+import watchServer from "../bundler/watchServer.js";
+import watchClient from "../bundler/watchClient.js";
+import pc from "picocolors";
+import logger from "../include/logger.js";
+import { getEntries } from "../include/entry.js";
+import { outDir } from "../bundler/config/output.js";
+import { WebSocketServer } from "ws";
+const root = process.cwd();
+let child;
+function start() {
+    child?.kill();
+    return new Promise((resolve, reject) => {
+        const filePath = path.join(outDir.server, "index.js");
+        child = spawn(process.execPath, [filePath], {
+            stdio: !child ? "inherit" : "pipe",
+        });
+        resolve(child);
+    });
+}
+const dev = async (rootEntry) => {
+    const wss = new WebSocketServer({
+        port: 8080,
+    });
+    let sockets = new Set();
+    const broadcast = (message) => {
+        sockets.forEach((socket) => {
+            if (socket.readyState === 1) {
+                socket.send(message);
+            }
+        });
+    };
+    wss.on("connection", (ws) => {
+        sockets.add(ws);
+        ws.on("close", () => {
+            sockets.delete(ws);
+        });
+        ws.on("message", (message) => {
+            if (message.toString() === "reload") {
+                start();
+            }
+        });
+    });
+    let firstBuild = true;
+    let _clientWatcher = null;
+    const clientWatcher = async (entries) => {
+        let changedFiles = new Set();
+        _clientWatcher?.close();
+        _clientWatcher = await watchClient(entries, {
+            onChange: (entry) => {
+                const _entry = entries.find((e) => e.file === entry);
+                let buildFile = _entry
+                    ? `${_entry.id}.js`
+                    : entry
+                        .replace(root.replaceAll("\\", "/"), "")
+                        .replace(/\.(ts|tsx|jsx)$/, ".js")
+                        // replace / from first character if exists
+                        .replace(/^\//, "");
+                changedFiles.add(buildFile);
+            },
+            onBuildEnd: () => {
+                if (changedFiles.size) {
+                    broadcast(JSON.stringify(Array.from(changedFiles)));
+                    changedFiles.clear();
+                }
+            },
+        });
+    };
+    const watch = await watchServer({
+        rootEntry,
+        onChange: async (entry) => {
+            logger.info(`reload server ${pc.yellow(entry.replace(root.replaceAll("\\", "/"), ""))}`, "update");
+        },
+        async onClientEntryChange(_entry, entries) {
+            await clientWatcher(entries);
+        },
+        onServerChange: async (entry, entries) => {
+            await start();
+        },
+        onBuildEnd: async () => {
+            if (firstBuild) {
+                firstBuild = false;
+                const entries = await getEntries();
+                await clientWatcher(entries);
+                await start();
+            }
+        },
+    });
+    process.on("SIGINT", () => {
+        child?.kill();
+        _clientWatcher?.close();
+        watch?.close();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        child?.kill();
+        _clientWatcher?.close();
+        watch?.close();
+        process.exit(0);
+    });
+};
+export default dev;

package/dist/bin/cli/start.d.ts

@@ -0,0 +1,2 @@
+declare const start: () => Promise<void>;
+export default start;

package/dist/bin/cli/start.js

@@ -0,0 +1,19 @@
+import path from "node:path";
+import { spawn } from "child_process";
+import { outDir } from "../bundler/config/output.js";
+let child;
+const start = async () => {
+    const filePath = path.join(outDir.server, "index.js");
+    child = spawn(process.execPath, [filePath], {
+        stdio: "inherit",
+    });
+    process.on("SIGINT", () => {
+        child?.kill();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        child?.kill();
+        process.exit(0);
+    });
+};
+export default start;

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

@@ -0,0 +1,3 @@
+import { XanixClientEntry } from "../types";
+export declare const getEntries: () => Promise<XanixClientEntry[]>;
+export declare const entriesEqual: (entries: XanixClientEntry[]) => Promise<boolean>;

package/dist/bin/include/entry.js

@@ -0,0 +1,28 @@
+import { readManifest } from "./manifest.js";
+export const getEntries = async () => {
+    const manifest = await readManifest();
+    if (!manifest) {
+        return [];
+    }
+    return manifest.entries;
+};
+export const entriesEqual = async (entries) => {
+    const manifest = await readManifest();
+    if (!manifest) {
+        return false;
+    }
+    if (manifest.entries.length !== entries.length) {
+        return false;
+    }
+    for (const entry of manifest.entries) {
+        const existingEntry = entries.find((e) => e.id === entry.id);
+        if (!existingEntry) {
+            return false;
+        }
+        if (existingEntry.name !== entry.name ||
+            existingEntry.file !== entry.file) {
+            return false;
+        }
+    }
+    return true;
+};

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

@@ -0,0 +1,10 @@
+declare const logger: {
+    info: (msg: string, title?: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    warnOnce: (msg: string) => void;
+    clearScreen: () => void;
+    hasErrorLogged: () => boolean;
+    hasWarned: boolean;
+};
+export default logger;

package/dist/bin/include/logger.js

@@ -0,0 +1,11 @@
+import pc from "picocolors";
+const logger = {
+    info: (msg, title = "xanix") => console.log(`${pc.blue(`[${title}]`)} ${msg}`),
+    warn: (msg) => console.log(`${pc.yellow("[xanix:warn]")} ${pc.yellow(msg)}`),
+    error: (msg) => console.log(`${pc.red("[xanix:error]")} ${pc.red(msg)}`),
+    warnOnce: (msg) => console.log(`${pc.yellow("[xanix:warn]")} ${pc.yellow(msg)}`),
+    clearScreen: () => { },
+    hasErrorLogged: () => false,
+    hasWarned: false,
+};
+export default logger;

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

@@ -0,0 +1,3 @@
+import { ClientManifest, XanixClientEntry } from "../types.js";
+export declare const createManifest: (entries: XanixClientEntry[]) => Promise<void>;
+export declare const readManifest: () => Promise<ClientManifest | null>;

package/dist/bin/include/manifest.js

@@ -0,0 +1,13 @@
+import path from "node:path";
+import fs from "node:fs";
+let readedManifest = null;
+export const createManifest = async (entries) => {
+    const manifest = {
+        id: `id_`,
+        entries: [...entries.values()],
+    };
+    readedManifest = manifest;
+    const outDir = path.resolve(process.cwd(), ".xanix");
+    fs.writeFileSync(path.resolve(outDir, "client-manifest.json"), JSON.stringify(manifest, null, 2));
+};
+export const readManifest = async () => readedManifest;

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

@@ -0,0 +1,2 @@
+export declare const getClientRuntimeFile: () => string;
+export declare const getDocumentFile: () => Promise<string>;

package/dist/bin/include/utils.js

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = fileURLToPath(import.meta.url);
+export const getClientRuntimeFile = () => {
+    return path.join(__dirname, "../../../client-runtime.js");
+};
+export const getDocumentFile = async () => {
+    const documentEntry = path.join(process.cwd(), "Document.tsx");
+    if (fs.existsSync(documentEntry)) {
+        return documentEntry;
+    }
+    return path.join(__dirname, "../../../components/BaseDocument.js");
+};

package/dist/bin/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import dev from "./cli/dev.js";
+import build from "./cli/build.js";
+import start from "./cli/start.js";
+const program = new Command();
+program.name("xanix").description("Xanix application CLI");
+program
+    .command("dev")
+    .description("Start the Xanix development server")
+    .argument("[entry]", "entry file", "index.tsx")
+    .action(async (entry) => {
+    await dev(entry);
+});
+program
+    .command("build")
+    .description("Build the Xanix application")
+    .argument("[entry]", "entry file", "index.tsx")
+    .action(async (entry) => {
+    await build(entry);
+});
+program
+    .command("start")
+    .description("Start the production server")
+    .action(start);
+await program.parseAsync();

package/dist/bin/types.d.ts

@@ -0,0 +1,12 @@
+export interface XanixClientEntry {
+    id: string;
+    name: string;
+    file: string;
+    path: string;
+    build: string;
+    export: string;
+}
+export type ClientManifest = {
+    id: string;
+    entries: Array<XanixClientEntry>;
+};

package/dist/bin/types.js

@@ -0,0 +1 @@
+export {};

package/dist/client/components/Body.d.ts

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

package/dist/client/components/Body.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useDocument } from "./Document/context.js";
+const Body = ({ children }) => {
+    const { scripts } = useDocument();
+    return (_jsxs("body", { children: [children, Array.isArray(scripts) &&
+                scripts
+                    .filter(({ placement }) => placement === "body")
+                    .map((s) => (_jsx("script", { src: s.src, type: s.type || "text/javascript" }, s.src)))] }));
+};
+export default Body;

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

@@ -0,0 +1,3 @@
+import { XanixDocumentData } from "../../../types";
+export declare const DocumentContext: import("react").Context<XanixDocumentData>;
+export declare const useDocument: () => XanixDocumentData;

package/dist/client/components/Document/context.js

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

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

@@ -0,0 +1,8 @@
+import type { XanixDocumentData } from "../../../types";
+import { HTMLProps } from "react";
+export type DocumentProps = HTMLProps<HTMLHtmlElement> & {
+    document: XanixDocumentData;
+    children: React.ReactNode;
+};
+declare const Document: ({ document, children, ...props }: DocumentProps) => import("react").JSX.Element;
+export default Document;

package/dist/client/components/Document/index.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DocumentContext } from "./context";
+const Document = ({ document, children, ...props }) => {
+    return (_jsx(DocumentContext.Provider, { value: document, children: _jsx("html", { ...props, children: children }) }));
+};
+export default Document;

package/dist/client/components/Head copy.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/client/components/Head copy.js

@@ -0,0 +1,8 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { getDocumentData } from "../../utils/index.js";
+const doc = getDocumentData();
+const Head = ({ children }) => {
+    doc.head = children;
+    return _jsx(_Fragment, {});
+};
+export default Head;

package/dist/client/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/client/components/Head.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useDocument } from "./Document/context.js";
+const Head = ({ children }) => {
+    const { title, meta, styles, scripts } = useDocument();
+    return (_jsxs("head", { children: [_jsx("title", { children: title }), Array.from(meta.entries()).map(([name, content]) => (_jsx("meta", { name: name, content: content }, name))), children, Array.from(styles).map((href) => (_jsx("link", { rel: "stylesheet", href: href }, href))), Array.isArray(scripts) &&
+                scripts
+                    .filter(({ placement }) => placement === "head")
+                    .map((s) => (_jsx("script", { src: s.src, type: s.type || "text/javascript" }, s.src)))] }));
+};
+export default Head;

package/dist/client/components/Link.d.ts

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

package/dist/client/components/Link.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { navigate } from "../navigation";
+const Link = ({ children, ...props }) => {
+    return (_jsx("a", { ...props, onClick: (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            navigate(props.href);
+        }, children: children }));
+};
+export default Link;

package/dist/client/context/RouteContext.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export declare const RouteContext: React.Context<string>;
+type RouteProviderProps = {
+    children: React.ReactNode;
+    value?: string;
+};
+export declare const RouteProvider: ({ children, value }: RouteProviderProps) => React.JSX.Element;
+export default RouteContext;

package/dist/client/context/RouteContext.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useMemo } from "react";
+export const RouteContext = React.createContext("");
+let dispach = null;
+export const RouteProvider = ({ children, value }) => {
+    const [route, setRoute] = React.useState(value || window.location.pathname);
+    useMemo(() => {
+        if (value) {
+            dispach = () => {
+                setRoute(value);
+            };
+        }
+    }, [value]);
+    return (_jsx(RouteContext.Provider, { value: route, children: children }));
+};
+export default RouteContext;

package/dist/client/hooks/usePageProps.d.ts

@@ -0,0 +1 @@
+declare const usePageProps: () => void;

package/dist/client/hooks/usePageProps.js

@@ -0,0 +1,2 @@
+"use strict";
+const usePageProps = () => { };

package/dist/client/hooks/useRoute.d.ts

@@ -0,0 +1 @@
+declare const useRoute: () => void;

package/dist/client/hooks/useRoute.js

@@ -0,0 +1,2 @@
+"use strict";
+const useRoute = () => { };

package/dist/client/hooks/useSearchParams.d.ts

@@ -0,0 +1 @@
+declare const useSearchParams: () => void;

package/dist/client/hooks/useSearchParams.js

@@ -0,0 +1,2 @@
+"use strict";
+const useSearchParams = () => { };

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+import { navigate, back, forward, preload } from "../navigation/navigation.js";
+export { navigate, back, forward, preload };

package/dist/client/index.js

@@ -0,0 +1,2 @@
+import { navigate, back, forward, preload } from "../navigation/navigation.js";
+export { navigate, back, forward, preload };

package/dist/client/navigation.d.ts

@@ -0,0 +1,4 @@
+export declare const navigate: (path: string) => void;
+export declare const back: () => void;
+export declare const forward: () => void;
+export declare const preload: (path: string) => Promise<void>;

package/dist/client/navigation.js

@@ -0,0 +1,14 @@
+export const navigate = (path) => {
+    window.dispatchEvent(new CustomEvent("xanix:navigate", {
+        detail: { path },
+    }));
+};
+export const back = () => {
+    window.history.back();
+};
+export const forward = () => {
+    window.history.forward();
+};
+export const preload = async (path) => {
+    window.dispatchEvent(new CustomEvent("xanix:preload", { detail: { path } }));
+};

package/dist/client/refresh.d.ts

@@ -0,0 +1,7 @@
+export type RefreshRecord = {
+    id: string;
+    current: Function;
+    previous?: Function;
+};
+export declare function register(component: Function, id: string): void;
+export declare function performRefresh(): void;