xanix 0.0.0 → 1.0.0

package/dist/BaseDocument.d.ts

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

package/dist/BaseDocument.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Head from "./document/Head.js";
+import Body from "./document/Body.js";
+import Document from "./document/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/Document.d.ts

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

package/dist/Document.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Head from "./components/Head.js";
+import Body from "./components/Body.js";
+const Document = ({ 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 Document;

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

@@ -0,0 +1,11 @@
+import { XanixClientEntry } from "../types";
+export type DependencyInfo = {
+    source: string;
+    resolved: string;
+    packageName: string;
+};
+export type CacheMetadata = Map<string, {
+    file: string;
+}>;
+declare const BuildCache: (entries: XanixClientEntry[]) => Promise<CacheMetadata>;
+export default BuildCache;

package/dist/bin/bundler/buildCache.js

@@ -0,0 +1,129 @@
+import path from "node:path";
+import { rollup } from "rollup";
+import { build } from "esbuild";
+import { createRequire } from "node:module";
+import { getDocumentFile } from "../include/utils.js";
+import esbuild from "rollup-plugin-esbuild";
+import url from "@rollup/plugin-url";
+const require = createRequire(import.meta.url);
+const GenerateGraph = async (entries) => {
+    const collector = new Map();
+    const input = {};
+    for (const entry of entries) {
+        input[entry.name] = entry.file;
+    }
+    input["xanix-runtime"] = require.resolve("xanix/runtime");
+    input["xanix-document"] = await getDocumentFile();
+    const bundle = await rollup({
+        input,
+        plugins: [
+            url({
+                include: [
+                    "**/*.jpg",
+                    "**/*.jpeg",
+                    "**/*.png",
+                    "**/*.gif",
+                    "**/*.webp",
+                    "**/*.svg",
+                    "**/*.ico",
+                    "**/*.woff",
+                    "**/*.woff2",
+                    "**/*.ttf",
+                    "**/*.eot",
+                ],
+                limit: 0,
+                fileName: "assets/[name]-[hash][extname]",
+                emitFiles: true,
+            }),
+            esbuild({
+                target: "es2022",
+                jsx: "automatic",
+                tsconfig: false,
+            }),
+        ],
+        external(id) {
+            if (id.startsWith(".") || path.isAbsolute(id)) {
+                return false;
+            }
+            collector.set(id, {
+                source: id,
+                resolved: require.resolve(id, {
+                    paths: [process.cwd()],
+                }),
+                packageName: id,
+            });
+            return true;
+        },
+    });
+    await bundle.close();
+    return collector;
+};
+// Wraps each CJS dep in a virtual ESM file that re-exports named exports detected via require()
+const makeCjsWrapperPlugin = (wrappers) => ({
+    name: "cjs-named-exports",
+    setup(build) {
+        build.onResolve({ filter: /\?cjs-wrapper$/ }, (args) => ({
+            path: args.path,
+            namespace: "cjs-wrapper",
+        }));
+        build.onLoad({ filter: /.*/, namespace: "cjs-wrapper" }, (args) => {
+            const contents = wrappers.get(args.path);
+            return { contents, resolveDir: process.cwd() };
+        });
+    },
+});
+const buildWrappers = (input) => {
+    const wrappers = new Map();
+    const wrappedInput = {};
+    for (const [name, resolved] of Object.entries(input)) {
+        const key = `${name}?cjs-wrapper`;
+        let namedExports = [];
+        try {
+            const mod = require(resolved);
+            namedExports = Object.keys(mod).filter((k) => k !== "__esModule" && k !== "default");
+        }
+        catch { }
+        const lines = [
+            `import __mod from ${JSON.stringify(resolved)};`,
+            `export default __mod;`,
+        ];
+        if (namedExports.length > 0) {
+            lines.push(`export const { ${namedExports.join(", ")} } = __mod;`);
+        }
+        wrappers.set(key, lines.join("\n"));
+        wrappedInput[name] = key;
+    }
+    return { wrappers, wrappedInput };
+};
+const bundleDeps = async (input, outdir) => {
+    const { wrappers, wrappedInput } = buildWrappers(input);
+    await build({
+        entryPoints: wrappedInput,
+        bundle: true,
+        splitting: true,
+        format: "esm",
+        target: "es2022",
+        outdir,
+        entryNames: "[name]",
+        chunkNames: "chunks/[hash]",
+        platform: "browser",
+        sourcemap: true,
+        plugins: [makeCjsWrapperPlugin(wrappers)],
+    });
+};
+const metadata = new Map();
+const BuildCache = async (entries) => {
+    const input = {};
+    const dependencies = await GenerateGraph(entries);
+    for (const dependency of dependencies.values()) {
+        const entryName = dependency.source.replace(/^@/, "").replace(/\//g, "-");
+        input[entryName] = dependency.resolved;
+        metadata.set(dependency.source, {
+            file: `${entryName}.js`,
+        });
+    }
+    const cacheDir = path.resolve(process.cwd(), ".xanix/cache");
+    await bundleDeps(input, cacheDir);
+    return metadata;
+};
+export default BuildCache;

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

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

package/dist/bin/bundler/buildClient.js

@@ -0,0 +1,41 @@
+import { rollup } from "rollup";
+import fs from "node:fs";
+import bundlerOutput, { outDir } from "./config/output.js";
+import { getDocumentFile, getClientRuntimeFile } from "../include/utils.js";
+import { xanixDefaultPlugins } from "./plugins/plugins.js";
+const buildClient = async (entries) => {
+    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 build = await rollup({
+        input,
+        treeshake: true,
+        onwarn(warning, warn) {
+            if (warning.code === "MODULE_LEVEL_DIRECTIVE" &&
+                warning.message.includes('"use client"')) {
+                return;
+            }
+            warn(warning);
+        },
+        plugins: [
+            ...xanixDefaultPlugins({
+                target: "client",
+                development: false,
+                assetExternal: true,
+            }),
+        ],
+    });
+    await build.write(bundlerOutput.client(entries, { isDev: false }));
+    await build.close();
+};
+export default buildClient;

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

@@ -0,0 +1,7 @@
+import { XanixClientEntry } from "../types.js";
+export type WatcherOptions = {
+    rootEntry: string;
+    onBuildEnd: (entries: XanixClientEntry[]) => Promise<void>;
+};
+declare const BuildServer: ({ rootEntry, onBuildEnd }: WatcherOptions) => Promise<void>;
+export default BuildServer;

package/dist/bin/bundler/buildServer.js

@@ -0,0 +1,55 @@
+import { rollup } from "rollup";
+import path from "node:path";
+import bundlerOutput, { outDir } from "./config/output.js";
+import fs from "node:fs";
+import { createManifest } from "../include/manifest.js";
+import generateClientEntries from "./generateClientEntries.js";
+import { getDocumentFile } from "../include/utils.js";
+import { xanixDefaultPlugins } from "./plugins/plugins.js";
+const root = process.cwd();
+const BuildServer = async ({ rootEntry, onBuildEnd }) => {
+    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 build = await rollup({
+        input,
+        treeshake: true,
+        onwarn(warning, warn) {
+            if (warning.code === "MODULE_LEVEL_DIRECTIVE" &&
+                warning.message.includes('"use client"')) {
+                return;
+            }
+            warn(warning);
+        },
+        plugins: [
+            ...xanixDefaultPlugins({
+                target: "server",
+                development: false,
+                assetExternal: false,
+            }),
+        ],
+        external(id) {
+            if (id.startsWith(".") ||
+                path.isAbsolute(id) ||
+                id === "@" ||
+                id.startsWith("@/")) {
+                return false;
+            }
+            return true;
+        },
+    });
+    await build.write(bundlerOutput.server());
+    await build.close();
+    await onBuildEnd(entries);
+};
+export default BuildServer;

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

@@ -0,0 +1,11 @@
+import { XanixClientEntry } from "../types";
+export type DependencyInfo = {
+    source: string;
+    resolved: string;
+    packageName: string;
+};
+export type CacheMetadata = Map<string, {
+    file: string;
+}>;
+declare const BuildCache: (entries: XanixClientEntry[]) => Promise<CacheMetadata>;
+export default BuildCache;

package/dist/bin/bundler/cacheNpmModules.js

@@ -0,0 +1,157 @@
+import path from "node:path";
+import { rollup } from "rollup";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import { build } from "esbuild";
+import { createRequire } from "node:module";
+import { getClientRuntimeFile, getDocumentFile } from "../include/utils.js";
+import esbuild from "rollup-plugin-esbuild";
+import url from "@rollup/plugin-url";
+const require = createRequire(import.meta.url);
+const GenerateGraph = async (entries) => {
+    const collector = new Map();
+    const input = [];
+    for (const entry of entries) {
+        input.push(entry.file);
+    }
+    input.push(getClientRuntimeFile());
+    input.push(await getDocumentFile());
+    const bundle = await rollup({
+        input,
+        plugins: [
+            // XanixTsconfigAlias(),
+            nodeResolve({
+                extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
+            }),
+            url({
+                include: [
+                    "**/*.jpg",
+                    "**/*.jpeg",
+                    "**/*.png",
+                    "**/*.gif",
+                    "**/*.webp",
+                    "**/*.svg",
+                    "**/*.ico",
+                    "**/*.woff",
+                    "**/*.woff2",
+                    "**/*.ttf",
+                    "**/*.eot",
+                    "**/*.css",
+                ],
+                limit: 0,
+                fileName: "assets/[name]-[hash][extname]",
+                emitFiles: false,
+            }),
+            esbuild({
+                target: "es2022",
+                jsx: "automatic",
+                tsconfig: false,
+            }),
+        ],
+        external(id) {
+            if (id.startsWith(".") ||
+                path.isAbsolute(id) ||
+                id === "@" ||
+                id.startsWith("@/")) {
+                return false;
+            }
+            collector.set(id, {
+                source: id,
+                resolved: require.resolve(id, {
+                    paths: [process.cwd()],
+                }),
+                packageName: id,
+            });
+            return true;
+        },
+    });
+    await bundle.close();
+    return collector;
+};
+// Wraps each CJS dep in a virtual ESM file that re-exports named exports detected via require()
+const makeCjsWrapperPlugin = (wrappers) => ({
+    name: "cjs-named-exports",
+    setup(build) {
+        build.onResolve({ filter: /\?cjs-wrapper$/ }, (args) => ({
+            path: args.path,
+            namespace: "cjs-wrapper",
+        }));
+        build.onLoad({ filter: /.*/, namespace: "cjs-wrapper" }, (args) => {
+            const contents = wrappers.get(args.path);
+            return { contents, resolveDir: process.cwd() };
+        });
+    },
+});
+const buildWrappers = (input) => {
+    const wrappers = new Map();
+    const wrappedInput = {};
+    for (const [name, resolved] of Object.entries(input)) {
+        const key = `${name}?cjs-wrapper`;
+        let namedExports = [];
+        let hasDefault = false;
+        try {
+            const mod = require(resolved);
+            hasDefault =
+                mod &&
+                    (typeof mod === "object" || typeof mod === "function") &&
+                    "default" in mod;
+            namedExports = Object.keys(mod).filter((key) => key !== "__esModule" && key !== "default");
+        }
+        catch { }
+        const lines = [`import * as __mod from ${JSON.stringify(resolved)};`];
+        if (hasDefault) {
+            lines.push(`export default __mod.default;`);
+        }
+        else {
+            lines.push(`export default __mod;`);
+        }
+        for (const exportName of namedExports) {
+            if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
+                lines.push(`export const ${exportName} = __mod[${JSON.stringify(exportName)}];`);
+            }
+        }
+        wrappers.set(key, lines.join("\n"));
+        wrappedInput[name] = key;
+    }
+    return {
+        wrappers,
+        wrappedInput,
+    };
+};
+const bundleDeps = async (input, outdir) => {
+    const { wrappers, wrappedInput } = buildWrappers(input);
+    await build({
+        entryPoints: wrappedInput,
+        bundle: true,
+        splitting: true,
+        format: "esm",
+        target: "es2022",
+        outdir,
+        entryNames: "[name]",
+        chunkNames: "chunks/[hash]",
+        platform: "browser",
+        sourcemap: true,
+        define: {
+            __XANIX_CLIENT__: "true",
+            __XANIX_SERVER__: "false",
+            __XANIX_DEV__: "true",
+            __XANIX_PROD__: "false",
+        },
+        plugins: [makeCjsWrapperPlugin(wrappers)],
+    });
+};
+const metadata = new Map();
+const BuildCache = async (entries) => {
+    const input = {};
+    const dependencies = await GenerateGraph(entries);
+    for (const dependency of dependencies.values()) {
+        const entryName = dependency.source.replace(/^@/, "").replace(/\//g, "-");
+        input[entryName] = dependency.resolved;
+        metadata.set(dependency.source, {
+            file: `${entryName}.js`,
+        });
+    }
+    const cacheDir = path.resolve(process.cwd(), ".xanix/cache");
+    await bundleDeps(input, cacheDir);
+    return metadata;
+};
+export default BuildCache;

package/dist/bin/bundler/config/output.d.ts

@@ -0,0 +1,14 @@
+import { OutputOptions } from "rollup";
+import { XanixClientEntry } from "../../types";
+export declare const outDir: {
+    server: string;
+    client: string;
+};
+type Options = {
+    isDev?: boolean;
+};
+declare const bundlerOutput: {
+    client: (entries: XanixClientEntry[], { isDev }: Options) => OutputOptions;
+    server: () => OutputOptions;
+};
+export default bundlerOutput;

package/dist/bin/bundler/config/output.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+const root = process.cwd();
+export const outDir = {
+    server: path.resolve(root, ".xanix"),
+    client: path.resolve(root, ".xanix/client"),
+};
+const client = (entries, { isDev }) => {
+    const _entries = {};
+    for (const entry of entries) {
+        _entries[entry.name] = entry;
+    }
+    const opt = {
+        dir: outDir.client,
+        format: "esm",
+        entryFileNames: (id) => {
+            const entry = _entries[id.name];
+            if (entry) {
+                return `${entry.id}.js`;
+            }
+            return `[name].js`;
+        },
+    };
+    if (isDev) {
+        opt.sourcemap = true;
+        opt.preserveModules = true;
+        opt.preserveModulesRoot = process.cwd();
+    }
+    else {
+        opt.chunkFileNames = "chunks/[hash].js";
+        opt.assetFileNames = "assets/[name]-[hash][extname]";
+    }
+    return opt;
+};
+const server = () => {
+    return {
+        dir: outDir.server,
+        format: "esm",
+        sourcemap: false,
+        entryFileNames: "[name].js",
+        chunkFileNames: "chunks/[hash].js",
+        assetFileNames: "assets/[hash][extname]",
+    };
+};
+const bundlerOutput = {
+    client,
+    server,
+};
+export default bundlerOutput;

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

@@ -0,0 +1,3 @@
+import { type XanixClientEntry } from "../types.js";
+declare const generateClientEntries: () => Promise<XanixClientEntry[]>;
+export default generateClientEntries;

package/dist/bin/bundler/generateClientEntries.js

@@ -0,0 +1,59 @@
+import { rollup } from "rollup";
+import path from "node:path";
+import { XanixEntryFinder } from "./plugins/XanixEntryFinder/index.js";
+import url from "@rollup/plugin-url";
+import esbuild from "rollup-plugin-esbuild";
+import XanixTsconfigAlias from "./plugins/XanixTsconfigAlias.js";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+const root = process.cwd();
+const generateClientEntries = async () => {
+    const entries = new Map();
+    const bundle = await rollup({
+        input: path.resolve(root, "index.tsx"),
+        plugins: [
+            XanixTsconfigAlias(),
+            nodeResolve({
+                extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
+            }),
+            XanixEntryFinder({
+                entries,
+            }),
+            url({
+                include: [
+                    "**/*.jpg",
+                    "**/*.jpeg",
+                    "**/*.png",
+                    "**/*.gif",
+                    "**/*.webp",
+                    "**/*.svg",
+                    "**/*.ico",
+                    "**/*.woff",
+                    "**/*.woff2",
+                    "**/*.ttf",
+                    "**/*.eot",
+                    "**/*.css",
+                ],
+                limit: 0,
+                fileName: "assets/[name]-[hash][extname]",
+                emitFiles: true,
+            }),
+            esbuild({
+                target: "es2022",
+                jsx: "automatic",
+                tsconfig: false,
+            }),
+        ],
+        external(id) {
+            if (id.startsWith(".") ||
+                path.isAbsolute(id) ||
+                id === "@" ||
+                id.startsWith("@/")) {
+                return false;
+            }
+            return true;
+        },
+    });
+    await bundle.close();
+    return Array.from(entries.values());
+};
+export default generateClientEntries;

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

@@ -0,0 +1,4 @@
+declare const xanixAssets: (options?: {
+    external: boolean;
+}) => import("rollup").Plugin<any>;
+export default xanixAssets;

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

@@ -0,0 +1,22 @@
+import url from "@rollup/plugin-url";
+const xanixAssets = (options) => {
+    return url({
+        include: [
+            "**/*.jpg",
+            "**/*.jpeg",
+            "**/*.png",
+            "**/*.gif",
+            "**/*.webp",
+            "**/*.svg",
+            "**/*.ico",
+            "**/*.woff",
+            "**/*.woff2",
+            "**/*.ttf",
+            "**/*.eot",
+        ],
+        limit: 0,
+        fileName: "assets/[name]-[hash][extname]",
+        emitFiles: !(options?.external ?? false),
+    });
+};
+export default xanixAssets;

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

@@ -0,0 +1,6 @@
+import type { Plugin } from "rollup";
+export interface XanixBrowserCodeOptions {
+    target?: "server" | "client";
+    globals?: string[];
+}
+export default function xanixBrowserCodeRemover(options?: XanixBrowserCodeOptions): Plugin;