xanix 1.0.18 → 1.0.19

package/dist/AppRoot.d.ts

@@ -0,0 +1,6 @@
+export type AppRootProps = {
+    Component: any;
+    doc: any;
+};
+declare const AppRoot: ({ Component, doc }: AppRootProps) => import("react").JSX.Element;
+export default AppRoot;

package/dist/AppRoot.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import pages from "virtual:xanix-pages";
+import Document from "virtual:xanix-document";
+import { useState, useEffect } from "react";
+import { DocumentProvider } from "./components/DocumentContext";
+import xanix from "./server/index.js";
+const AppRoot = ({ Component, doc }) => {
+    const [_document, setDocument] = useState(doc);
+    useEffect(() => {
+        xanix.on("navigate:end", setDocument);
+    }, []);
+    const ComponentToRender = pages[_document.page.id] || Component;
+    return (_jsx(DocumentProvider, { value: _document, children: _jsx(Document, { children: _jsx(ComponentToRender, {}) }) }));
+};
+export default AppRoot;

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

@@ -0,0 +1 @@
+export declare function Caching(): Promise<void>;

package/dist/bin/bundler/Cache.js

@@ -0,0 +1,210 @@
+import path from "node:path";
+import fs from "node:fs";
+import { rolldown, watch } from "rolldown";
+const root = process.cwd();
+const appEntry = path.resolve(root, "src/index.ts");
+const outDir = path.resolve(root, ".xanix");
+const cacheDir = path.join(outDir, "cache");
+function normalize(id) {
+    return id.replace(/\\/g, "/");
+}
+function isNodeModule(id) {
+    return normalize(id).includes("/node_modules/");
+}
+function getPackageName(id) {
+    const normalized = normalize(id);
+    const match = normalized.match(/\/node_modules\/((?:@[^/]+\/)?[^/]+)/);
+    if (!match) {
+        return null;
+    }
+    return match[1];
+}
+function getSafeEntryName(packageName) {
+    return packageName
+        .replace(/^@/, "")
+        .replace(/\//g, "-")
+        .replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+/**
+ * Finds the package root from a node_modules file.
+ */
+function getPackageRoot(id) {
+    const normalized = normalize(id);
+    const index = normalized.lastIndexOf("/node_modules/");
+    if (index === -1) {
+        return null;
+    }
+    const after = normalized.slice(index + "/node_modules/".length);
+    const parts = after.split("/");
+    if (parts[0].startsWith("@")) {
+        if (!parts[1]) {
+            return null;
+        }
+        return path.join(normalized.slice(0, index), "node_modules", parts[0], parts[1]);
+    }
+    return path.join(normalized.slice(0, index), "node_modules", parts[0]);
+}
+/**
+ * Plugin used only to discover node_modules dependencies.
+ */
+function discoverDependencies() {
+    const dependencies = new Map();
+    const plugin = {
+        name: "xanix-discover-dependencies",
+        resolveId(source, importer) {
+            if (!importer) {
+                return null;
+            }
+            return null;
+        },
+        load(id) {
+            if (!isNodeModule(id)) {
+                return null;
+            }
+            const packageName = getPackageName(id);
+            if (!packageName) {
+                return null;
+            }
+            if (!dependencies.has(packageName)) {
+                dependencies.set(packageName, id);
+            }
+            return null;
+        },
+    };
+    return {
+        plugin,
+        dependencies,
+    };
+}
+/**
+ * Build the input object dynamically.
+ *
+ * IMPORTANT:
+ *
+ * The dependencies need to become independent entries.
+ */
+async function createInputs() {
+    const discovered = new Map();
+    const plugin = {
+        name: "xanix-discover",
+        resolveId(source, importer) {
+            return null;
+        },
+        load(id) {
+            if (!isNodeModule(id)) {
+                return null;
+            }
+            const packageName = getPackageName(id);
+            if (packageName) {
+                discovered.set(packageName, id);
+            }
+            return null;
+        },
+    };
+    /*
+     * First build only to discover the dependency graph.
+     */
+    const discoveryBundle = await rolldown({
+        input: appEntry,
+        plugins: [plugin],
+    });
+    await discoveryBundle.generate({
+        format: "esm",
+    });
+    /*
+     * Add the application entry.
+     */
+    const inputs = {
+        app: appEntry,
+    };
+    /*
+     * Add each discovered npm package as an independent entry.
+     */
+    for (const [packageName, id] of discovered) {
+        const entryName = getSafeEntryName(packageName);
+        inputs[`dep_${entryName}`] = id;
+    }
+    return inputs;
+}
+/**
+ * Cache plugin.
+ *
+ * This does NOT rebuild the dependencies separately.
+ *
+ * They are entries in the SAME Rolldown watch.
+ */
+function xanixCachePlugin() {
+    return {
+        name: "xanix-cache",
+        outputOptions(options) {
+            return {
+                ...options,
+                entryFileNames(chunk) {
+                    if (chunk.name.startsWith("dep_")) {
+                        const name = chunk.name.slice("dep_".length);
+                        return `cache/${name}.js`;
+                    }
+                    return "[name].js";
+                },
+            };
+        },
+    };
+}
+export async function Caching() {
+    fs.mkdirSync(cacheDir, {
+        recursive: true,
+    });
+    /*
+     * Discover dependencies once when creating the watch graph.
+     */
+    const inputs = await createInputs();
+    console.log("Rolldown watch entries:");
+    for (const [name, value] of Object.entries(inputs)) {
+        console.log(`  ${name} → ${value}`);
+    }
+    /*
+     * ONE Rolldown watch.
+     *
+     * No buildDependencyCache().
+     * No external dependency build.
+     */
+    const watcher = await watch({
+        input: inputs,
+        plugins: [xanixCachePlugin()],
+        output: {
+            dir: outDir,
+            format: "esm",
+            entryFileNames: (chunk) => {
+                if (chunk.name.startsWith("dep_")) {
+                    const name = chunk.name.slice("dep_".length);
+                    return `cache/${name}.js`;
+                }
+                return "[name].js";
+            },
+            chunkFileNames: "chunks/[name]-[hash].js",
+            assetFileNames: "assets/[name]-[hash][extname]",
+        },
+        watch: {
+            include: ["src/**", "node_modules/**"],
+        },
+    });
+    watcher.on("event", (event) => {
+        switch (event.code) {
+            case "START":
+                console.log("watch started");
+                break;
+            case "BUNDLE_START":
+                console.log("building...");
+                break;
+            case "BUNDLE_END":
+                console.log(`built in ${event.duration}ms`);
+                break;
+            case "END":
+                console.log("waiting for changes...");
+                break;
+            case "ERROR":
+                console.error(event.error);
+                break;
+        }
+    });
+}

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

@@ -0,0 +1,3 @@
+import { Plugin } from "rollup";
+declare const external: () => Plugin;
+export default external;

package/dist/bin/bundler/External.js

@@ -0,0 +1,6 @@
+const external = () => {
+    return {
+        name: "external",
+    };
+};
+export default external;

package/dist/bin/bundler/buildClient.js

@@ -1,4 +1,4 @@
-import { rollup } from "rollup";
+import { rolldown } from "rolldown";
 import fs from "node:fs";
 import bundlerOutput from "./config/output.js";
 import { getClientRuntimeFile, getClientRuntimeFileName, } from "../include/utils.js";
@@ -18,7 +18,7 @@ const buildClient = async (entries) => {
     fs.mkdirSync(outdirs.client, {
         recursive: true,
     });
-    const build = await rollup({
+    const build = await rolldown({
         input,
         treeshake: true,
         onwarn(warning, warn) {

package/dist/bin/bundler/buildServer.js

@@ -1,4 +1,4 @@
-import { rollup } from "rollup";
+import { rolldown } from "rolldown";
 import path from "node:path";
 import bundlerOutput from "./config/output.js";
 import fs from "node:fs";
@@ -18,7 +18,7 @@ const BuildServer = async ({ rootEntry, onBuildEnd }) => {
     const input = {
         index: path.resolve(root, rootEntry),
     };
-    const build = await rollup({
+    const build = await rolldown({
         input,
         treeshake: true,
         onwarn(warning, warn) {

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

@@ -0,0 +1,3 @@
+import type { CachedModule } from "./types.js";
+declare const buildCache: (cached: Map<string, CachedModule>) => Promise<void>;
+export default buildCache;

package/dist/bin/bundler/cache/buildCache.js

@@ -0,0 +1,76 @@
+import { rolldown } from "rolldown";
+import loadEnv from "../../include/loadEnv.js";
+import outdirs from "../../../outdirs.js";
+const VIRTUAL_PREFIX = "\0xanix-cache:";
+const buildCache = async (cached) => {
+    const input = {};
+    for (const [source, { name }] of cached) {
+        input[name] = `${VIRTUAL_PREFIX}${name}`;
+    }
+    const build = await rolldown({
+        input,
+        treeshake: true,
+        platform: "browser",
+        tsconfig: true,
+        checks: {
+            moduleLevelDirective: false,
+        },
+        resolve: {
+            extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
+            conditionNames: ["browser", "import", "module", "default"],
+        },
+        transform: {
+            target: "es2020",
+            jsx: {
+                runtime: "automatic",
+            },
+            define: await loadEnv({
+                mode: "development",
+                isClient: false,
+            }),
+        },
+        plugins: [
+            {
+                name: "CacheEntry",
+                resolveId(source) {
+                    if (source.startsWith(VIRTUAL_PREFIX)) {
+                        return source;
+                    }
+                    return null;
+                },
+                load(id) {
+                    if (!id.startsWith(VIRTUAL_PREFIX)) {
+                        return null;
+                    }
+                    const name = id.slice(VIRTUAL_PREFIX.length);
+                    const cache = [...cached.values()].find((item) => item.name === name);
+                    if (!cache) {
+                        return null;
+                    }
+                    const resolved = cache.resolved || cache.module;
+                    if (cache.default) {
+                        return `
+import * as __xanix_namespace from ${JSON.stringify(resolved)};
+
+export default __xanix_namespace.default;
+export { __xanix_namespace };
+`;
+                    }
+                    return `
+import * as __xanix_namespace from ${JSON.stringify(resolved)};
+
+export default __xanix_namespace;
+export { __xanix_namespace };
+`;
+                },
+            },
+        ],
+    });
+    await build.write({
+        dir: outdirs.module_cache,
+        format: "es",
+        entryFileNames: "[name].js",
+    });
+    await build.close();
+};
+export default buildCache;

package/dist/bin/bundler/cache/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from "rolldown";
+declare const XanixCache: () => Plugin;
+export default XanixCache;

package/dist/bin/bundler/cache/index.js

@@ -0,0 +1,216 @@
+import { createRequire } from "node:module";
+import { isPackageImport, makeFilename } from "./utils.js";
+import buildCache from "./buildCache.js";
+import { walk } from "oxc-walker";
+import { builtinModules } from "node:module";
+import { readManifest, writeManifest } from "./manifest.js";
+import logger from "../../include/logger.js";
+import pc from "picocolors";
+const nodeBuiltins = new Set(builtinModules);
+function isNodeBuiltin(id) {
+    const normalized = id.startsWith("node:") ? id.slice(5) : id;
+    return nodeBuiltins.has(normalized);
+}
+const require = createRequire(import.meta.url);
+function getParserLanguage(id) {
+    const cleanId = id.split("?")[0];
+    if (cleanId.endsWith(".tsx"))
+        return "tsx";
+    if (cleanId.endsWith(".ts"))
+        return "ts";
+    if (cleanId.endsWith(".jsx"))
+        return "jsx";
+    return "js";
+}
+function makeImportName(name) {
+    return `require_${name.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
+}
+const XanixCache = () => {
+    const cached = new Map();
+    let init = false;
+    return {
+        name: "__xmod",
+        buildStart() {
+            cached.clear();
+        },
+        watchChange() {
+            cached.clear();
+        },
+        async resolveId(source) {
+            if (source.startsWith("/__xmod")) {
+                return {
+                    id: source,
+                    external: true,
+                };
+            }
+            return null;
+        },
+        async transform(code, id) {
+            if (id.includes("/node_modules/") || id.includes("/.xanix/")) {
+                return null;
+            }
+            if (!code.includes("import ") && !code.includes("import(")) {
+                return null;
+            }
+            const lang = getParserLanguage(id);
+            const ast = this.parse(code, { lang });
+            const packages = [];
+            let replacements = [];
+            walk(ast, {
+                enter(node) {
+                    if (node.type !== "ImportDeclaration" || node.importKind === "type") {
+                        return;
+                    }
+                    const source = node.source.value;
+                    if (typeof source !== "string" ||
+                        !isPackageImport(source) ||
+                        isNodeBuiltin(source)) {
+                        return;
+                    }
+                    /*
+                     * Don't add the same package multiple times
+                     * when the file imports it more than once.
+                     */
+                    if (!packages.includes(source)) {
+                        packages.push(source);
+                    }
+                    const name = makeFilename(source);
+                    const importName = makeImportName(name);
+                    const cachePath = `/__xmod/${name}.js`;
+                    const lines = [];
+                    const specifiers = (node.specifiers ?? []).filter((specifier) => specifier.importKind !== "type");
+                    if (!specifiers.length) {
+                        lines.push(`import "${cachePath}";`);
+                    }
+                    else {
+                        const defaultSpecifier = specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier");
+                        const namespaceSpecifier = specifiers.find((specifier) => specifier.type === "ImportNamespaceSpecifier");
+                        const namedSpecifiers = specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
+                        /*
+                         * Only import default when the original import
+                         * actually has a default import.
+                         */
+                        if (defaultSpecifier) {
+                            lines.push(`import ${importName} from "${cachePath}";`);
+                            lines.push(`const ${defaultSpecifier.local.name} = ${importName};`);
+                        }
+                        /*
+                         * Namespace and named imports use the Xanix
+                         * namespace export.
+                         */
+                        if (namespaceSpecifier || namedSpecifiers.length) {
+                            const namespaceName = `${importName}_ns`;
+                            lines.push(`import { __xanix_namespace as ${namespaceName} } from "${cachePath}";`);
+                            if (namespaceSpecifier) {
+                                lines.push(`const ${namespaceSpecifier.local.name} = ${namespaceName};`);
+                            }
+                            if (namedSpecifiers.length) {
+                                const properties = namedSpecifiers
+                                    .map((specifier) => {
+                                    const imported = specifier.imported?.type === "Identifier"
+                                        ? specifier.imported.name
+                                        : specifier.imported?.value;
+                                    const local = specifier.local?.name;
+                                    if (!imported || !local) {
+                                        return null;
+                                    }
+                                    if (imported !== local) {
+                                        if (typeof imported === "string" &&
+                                            !/^[$A-Z_a-z][$\w]*$/.test(imported)) {
+                                            return `${JSON.stringify(imported)}: ${local}`;
+                                        }
+                                        return `${imported}: ${local}`;
+                                    }
+                                    return imported;
+                                })
+                                    .filter(Boolean)
+                                    .join(", ");
+                                if (properties) {
+                                    lines.push(`const { ${properties} } = ${namespaceName};`);
+                                }
+                            }
+                        }
+                    }
+                    if (!cached.has(source)) {
+                        cached.set(source, {
+                            module: source,
+                            name,
+                            resolved: "",
+                            exports: [],
+                            default: false,
+                        });
+                    }
+                    replacements.push({
+                        source,
+                        start: node.start,
+                        end: node.end,
+                        value: lines.join("\n"),
+                    });
+                },
+            });
+            if (!replacements.length) {
+                return null;
+            }
+            /*
+             * Resolve ONLY newly discovered packages.
+             *
+             * Never loop through the entire cache here.
+             */
+            for (const source of packages) {
+                const cache = cached.get(source);
+                if (!cache || cache.resolved)
+                    continue;
+                try {
+                    const resolved = await this.resolve(source, id);
+                    if (!resolved?.id || !resolved.id.includes("node_modules")) {
+                        throw new Error(`Resolved module ${resolved.id} is not in node_modules`);
+                    }
+                    cache.resolved = resolved.id;
+                    const mod = require(resolved.id);
+                    cache.exports = Object.keys(mod);
+                    cache.default = Object.prototype.hasOwnProperty.call(mod, "default");
+                }
+                catch (error) {
+                    cached.delete(source);
+                }
+            }
+            for (let rep of replacements) {
+                const cache = cached.get(rep.source);
+                if (!cache ||
+                    !cache.resolved ||
+                    !cache.resolved.includes("node_modules")) {
+                    replacements = replacements.filter((r) => r.source !== rep.source);
+                }
+            }
+            /*
+             * Apply replacements only when this file actually
+             * contained cacheable imports.
+             */
+            const sorted = replacements.sort((a, b) => b.start - a.start);
+            for (const { start, end, value } of sorted) {
+                code = code.slice(0, start) + value + code.slice(end);
+            }
+            return {
+                code,
+                map: null,
+            };
+        },
+        async generateBundle() {
+            // write manifest
+            const cachedManifest = await readManifest();
+            const pmodules = Array.from(cachedManifest.values()).map((m) => m.module);
+            const cmodule = Array.from(cached.values()).map((m) => m.module);
+            const hasChanges = pmodules.some((m) => !cmodule.includes(m)) ||
+                cmodule.some((m) => !pmodules.includes(m));
+            if (hasChanges) {
+                if (init) {
+                    logger.info(`${pc.yellow("Optimizing dependencies")} `, "[optimize]");
+                }
+                init = true;
+                await buildCache(cached);
+                await writeManifest(cached);
+            }
+        },
+    };
+};
+export default XanixCache;

package/dist/bin/bundler/cache/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { CachedMap } from "./types.js";
+export declare const writeManifest: (manifest: CachedMap) => Promise<void>;
+export declare const readManifest: () => Promise<CachedMap>;

package/dist/bin/bundler/cache/manifest.js

@@ -0,0 +1,27 @@
+import fs from "fs/promises";
+import outdirs from "../../../outdirs.js";
+const manifestFile = `${outdirs.module_cache}/manifest.json`;
+export const writeManifest = async (manifest) => {
+    const data = Array.from(manifest.values());
+    for (const item of data) {
+        delete item.exports;
+        delete item.default;
+        delete item.resolved;
+        delete item.name;
+    }
+    await fs.writeFile(manifestFile, JSON.stringify(data, null, 2), "utf-8");
+};
+export const readManifest = async () => {
+    try {
+        const content = await fs.readFile(manifestFile, "utf-8");
+        const parsed = JSON.parse(content);
+        let data = new Map();
+        for (let p of parsed) {
+            data.set(p.module, p);
+        }
+        return data;
+    }
+    catch {
+        return new Map();
+    }
+};

package/dist/bin/bundler/cache/plugin/Transformer.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "rolldown";
+declare const CacheExportPlugin: () => Plugin;
+export default CacheExportPlugin;

package/dist/bin/bundler/cache/plugin/Transformer.js

@@ -0,0 +1,42 @@
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const exportsMap = new Map();
+const CacheExportPlugin = () => {
+    return {
+        name: "cache-export",
+        load(id) {
+            if (!id.includes("node_modules")) {
+                return null;
+            }
+            try {
+                const mod = require(id);
+                const names = Object.keys(mod);
+                exportsMap.set(id, names);
+                console.log(id, names);
+            }
+            catch {
+                // ignore modules that cannot be require()'d
+            }
+            return null;
+        },
+        generateBundle(_options, bundle) {
+            for (const output of Object.values(bundle)) {
+                if (output.type !== "chunk" || !output.isEntry) {
+                    continue;
+                }
+                const id = output.facadeModuleId;
+                if (!id) {
+                    continue;
+                }
+                const names = exportsMap.get(id);
+                if (!names) {
+                    continue;
+                }
+                console.log("Generating:", id);
+                console.log("Exports:", names);
+                // Here you generate your ESM exports.
+            }
+        },
+    };
+};
+export default CacheExportPlugin;

package/dist/bin/bundler/cache/types.d.ts

@@ -0,0 +1,8 @@
+export type CachedModule = {
+    module: string;
+    name: string;
+    resolved: string;
+    exports: string[];
+    default: boolean;
+};
+export type CachedMap = Map<string, CachedModule>;

package/dist/bin/bundler/cache/types.js

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

package/dist/bin/bundler/cache/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function isPackageImport(source: string): boolean;
+export declare const makeFilename: (id: string) => string;
+export declare const writeCacheManifest: (cached: Map<string, string>) => Promise<void>;
+export declare const readCacheManifest: () => Promise<Map<any, any>>;
+export declare function isNodeBuiltin(id: string): boolean;