xanix 1.0.18 → 1.0.19

package/dist/bin/bundler/client/plugins/Transformer/transformModuleCache.js

@@ -0,0 +1,120 @@
+import { builtinModules } from "node:module";
+import { isPackageImport, makeFilename } from "../../../cache/utils.js";
+const nodeBuiltins = new Set(builtinModules);
+function isNodeBuiltin(id) {
+    const normalized = id.startsWith("node:") ? id.slice(5) : id;
+    return nodeBuiltins.has(normalized);
+}
+function makeImportName(name) {
+    return `require_${name.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
+}
+function getCachePath(moduleName) {
+    const safeName = moduleName
+        .replace(/^@/, "")
+        .replace(/[\/\\]/g, "_")
+        .replace(/[^a-zA-Z0-9_$.-]/g, "_");
+    return `/cache/${safeName}.js`;
+}
+class TransformModuleCache {
+    constructor(cached) {
+        this.packages = [];
+        this.replacements = [];
+        this.cacheChanged = false;
+        this.cached = cached;
+    }
+    transform(node) {
+        if (node.type !== "ImportDeclaration" || node.importKind === "type") {
+            return;
+        }
+        const source = node.source.value;
+        if (typeof source !== "string" ||
+            !isPackageImport(source) ||
+            source === "xanix" ||
+            isNodeBuiltin(source)) {
+            return;
+        }
+        /*
+         * Don't add the same package multiple times
+         * when the file imports it more than once.
+         */
+        if (!this.packages.includes(source)) {
+            this.packages.push(source);
+        }
+        const name = makeFilename(source);
+        const importName = makeImportName(name);
+        const cachePath = `/xanix-cache/${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};`);
+                    }
+                }
+            }
+        }
+        /*
+         * Add the package only once.
+         */
+        if (!this.cached.has(source)) {
+            this.cacheChanged = true;
+            this.cached.set(source, {
+                module: source,
+                name,
+                resolved: "",
+                exports: [],
+                default: false,
+            });
+        }
+        this.replacements.push({
+            start: node.start,
+            end: node.end,
+            value: lines.join("\n"),
+        });
+    }
+}
+export default TransformModuleCache;

package/dist/bin/bundler/client/plugins/Transformer copy.d.ts

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

package/dist/bin/bundler/client/plugins/Transformer copy.js

@@ -0,0 +1,70 @@
+import { walk } from "oxc-walker";
+import path from "path";
+import TransformServerAction from "./Transformer/TransformServerAction.js";
+import TransformUseServer from "./Transformer/TransformUseServer.js";
+import TransformCache from "./Transformer/TransformCache.js";
+import crypto from "node:crypto";
+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";
+}
+const XanixTransformer = () => {
+    return {
+        name: "xanix-transform",
+        async transform(code, id) {
+            if (id.includes("node_modules")) {
+                return null;
+            }
+            const ext = path.extname(id);
+            if (ext !== ".tsx" && ext !== ".jsx") {
+                return null;
+            }
+            const uid = crypto
+                .createHash("sha256")
+                .update(id)
+                .digest("hex")
+                .slice(0, 12);
+            const lang = getParserLanguage(id);
+            const ast = this.parse(code, { lang });
+            const transformServerAction = new TransformServerAction(code, id, uid);
+            const transformUseServer = new TransformUseServer(code, id, uid);
+            const transformCache = new TransformCache(code, id, uid);
+            // const transformModuleCache = new TransformModuleCache();
+            walk(ast, {
+                enter(node) {
+                    transformServerAction.transform(node);
+                    transformUseServer.transform(node);
+                    transformCache.transform(node);
+                    // transformModuleCache.transform(node);
+                },
+            });
+            let replacements = [...transformUseServer.replacements];
+            if (transformServerAction.serverImported) {
+                replacements = [...replacements, ...transformServerAction.replacements];
+            }
+            if (transformCache.cacheImported) {
+                replacements = [...replacements, ...transformCache.replacements];
+            }
+            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);
+            }
+            let needImport = !transformUseServer.serverImported;
+            const useServerCode = `
+      ${needImport ? 'import * as __xanix from "xanix";' : ""}
+      ${transformUseServer.serverCodes.join("\n")}
+      `;
+            return {
+                code: useServerCode + "\n" + code,
+                map: null,
+            };
+        },
+    };
+};
+export default XanixTransformer;

package/dist/bin/bundler/client/plugins/Transformer.d.ts

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

package/dist/bin/bundler/client/plugins/Transformer.js

@@ -0,0 +1,26 @@
+import stripComments from "../../../modifier/sriptCommnet.js";
+import TransformCacheFunction from "./transformer/TransformCacheFunction.js";
+import TransformCreateSession from "./transformer/TransformCreateSession.js";
+import importFinder from "../../../modifier/importFinder.js";
+import TransformServerFunction from "./transformer/TransformServerFunction.js";
+import { uuid, frameworkDir } from "../../../include/utils.js";
+const XanixTransformer = () => {
+    return {
+        name: "xanix-transform",
+        async transform(code, id) {
+            const xanixImports = importFinder(code, "xanix");
+            if (xanixImports.length || id.startsWith(frameworkDir)) {
+                const uid = uuid(id, 12);
+                code = stripComments(code);
+                code = TransformServerFunction(code, xanixImports, uid, id);
+                code = TransformCacheFunction(code, xanixImports, uid, id);
+                code = TransformCreateSession(code, xanixImports, uid, id);
+            }
+            return {
+                code,
+                map: null,
+            };
+        },
+    };
+};
+export default XanixTransformer;

package/dist/bin/bundler/client/plugins/VirtualDev.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "rolldown";
+export default function VirtualDev(dev: boolean): Plugin;

package/dist/bin/bundler/client/plugins/VirtualDev.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const VIRTUAL_ID = "virtual:xanix-dev";
+const RESOLVED_ID = "\0virtual:xanix-dev";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const filepath = path.resolve(path.resolve(__dirname, "../../../../dev.js"));
+export default function VirtualDev(dev) {
+    return {
+        name: "xanix-dev",
+        resolveId(id) {
+            if (id === VIRTUAL_ID) {
+                return RESOLVED_ID;
+            }
+            return null;
+        },
+        async load(id) {
+            if (id !== RESOLVED_ID) {
+                return null;
+            }
+            if (!dev) {
+                return {
+                    code: "",
+                    map: null,
+                };
+            }
+            const source = await fs.promises.readFile(filepath, "utf8");
+            return {
+                code: source,
+                map: null,
+            };
+        },
+    };
+}

package/dist/bin/bundler/client/plugins/XanixPages.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "rolldown";
+export default function XanixAppRoot(): Plugin;

package/dist/bin/bundler/client/plugins/XanixPages.js

@@ -0,0 +1,37 @@
+import { getManifest } from "../../../include/manifest.js";
+const VIRTUAL_ID = "virtual:xanix-pages";
+const RESOLVED_ID = "\0virtual:xanix-pages";
+export default function XanixAppRoot() {
+    return {
+        name: "xanix-pages",
+        resolveId(id) {
+            if (id === VIRTUAL_ID) {
+                return RESOLVED_ID;
+            }
+            return null;
+        },
+        async load(id) {
+            if (id !== RESOLVED_ID) {
+                return null;
+            }
+            const clients = await getManifest();
+            const pages = [];
+            for (const client of clients) {
+                pages.push(`
+          pages[${JSON.stringify(client.id)}] = () =>
+            import(${JSON.stringify(client.resolved)});
+        `);
+            }
+            return {
+                code: `
+          import React from "react";
+          const pages = {};
+          ${pages.join("\n")}
+          export default pages;
+        `,
+                map: null,
+                moduleType: "js",
+            };
+        },
+    };
+}

package/dist/bin/bundler/client/plugins/XanixReactRefresh.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "rolldown";
+export default function xanixReactRefresh(): Plugin;

package/dist/bin/bundler/client/plugins/XanixReactRefresh.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import fs from "node:fs";
+import { getClientRuntimeFile } from "../../../include/utils.js";
+export default function xanixReactRefresh() {
+    return {
+        name: "xanix-react-refresh",
+        load(id) {
+            if (path.resolve(id) !== getClientRuntimeFile()) {
+                return null;
+            }
+            const code = fs.readFileSync(id, "utf8");
+            const refreshCode = `
+
+${code}
+`;
+            return {
+                code: refreshCode,
+                map: null,
+            };
+        },
+    };
+}

package/dist/bin/bundler/client/plugins/replacer/cacheFunctionReplacer.d.ts

@@ -0,0 +1,3 @@
+import { ImportInfo } from "../../../../modifier/importFinder.js";
+declare const cacheFunctionReplacer: (code: string, imports: ImportInfo[], uid: string) => string;
+export default cacheFunctionReplacer;

package/dist/bin/bundler/client/plugins/replacer/cacheFunctionReplacer.js

@@ -0,0 +1,28 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+const cacheFunctionReplacer = (code, imports, uid) => {
+    let count = 0;
+    const replacer = (code, cb) => {
+        const replacedCode = callbackReplacer(code, cb, (args) => {
+            if (args[2])
+                return;
+            const id = uid + count++;
+            const fn = args[0];
+            const options = args[1] || "undefined";
+            return `${cb}(${fn}, ${options}, "${id}");`;
+        });
+        code = replacedCode;
+        return code;
+    };
+    for (let _import of imports) {
+        if (_import.namespace) {
+            code = replacer(code, `${_import.namespace}.cache`);
+        }
+        for (let sp of _import.specifiers) {
+            if (sp.imported === "cache") {
+                code = replacer(code, sp.local);
+            }
+        }
+    }
+    return code;
+};
+export default cacheFunctionReplacer;

package/dist/bin/bundler/client/plugins/replacer/serverFunctionReplacer.d.ts

@@ -0,0 +1,3 @@
+import { ImportInfo } from "../../../../modifier/importFinder.js";
+declare const serverFunctionReplacer: (code: string, imports: ImportInfo[], uid: string) => string;
+export default serverFunctionReplacer;

package/dist/bin/bundler/client/plugins/replacer/serverFunctionReplacer.js

@@ -0,0 +1,28 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+const serverFunctionReplacer = (code, imports, uid) => {
+    let count = 0;
+    const replacer = (code, cb) => {
+        const replacedCode = callbackReplacer(code, cb, (args) => {
+            if (args[2])
+                return;
+            const id = uid + count++;
+            const fn = args[0];
+            const options = args[1] || "undefined";
+            return `${cb}(undefined, ${options}, "${id}");`;
+        });
+        code = replacedCode;
+        return code;
+    };
+    for (let _import of imports) {
+        if (_import.namespace) {
+            code = replacer(code, `${_import.namespace}.server`);
+        }
+        for (let sp of _import.specifiers) {
+            if (sp.imported === "server") {
+                code = replacer(code, sp.local);
+            }
+        }
+    }
+    return code;
+};
+export default serverFunctionReplacer;

package/dist/bin/bundler/client/plugins/replacer/useServerReplacer.d.ts

@@ -0,0 +1,3 @@
+import type { ImportInfo } from "../../../../modifier/importFinder";
+declare const useServerReplacer: (code: string, imports: ImportInfo[]) => string;
+export default useServerReplacer;

package/dist/bin/bundler/client/plugins/replacer/useServerReplacer.js

@@ -0,0 +1,38 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+const useServerReplacer = (code, imports) => {
+    if (!imports.length)
+        return code;
+    const importName = `__xanix_server_${Math.random().toString(36).substring(2, 3)}`;
+    let codes = [`import { server as ${importName} } from "xanix"`];
+    imports.push({
+        specifiers: [
+            {
+                imported: "server",
+                local: importName,
+            },
+        ],
+    });
+    const replacer = (code, cb) => {
+        return callbackReplacer(code, cb, (args) => {
+            const fn = args[0];
+            const argString = args[1] ?? "undefined";
+            const options = args[2] || "undefined";
+            const varname = `_xserver_${Math.random().toString(36).substring(2, 7)}`;
+            const server_code = `const ${varname} = ${importName}(${fn}, ${options});`;
+            codes.push(server_code);
+            return `${cb}(${varname}, ${argString})`;
+        });
+    };
+    for (let _import of imports) {
+        if (_import.namespace) {
+            code = replacer(code, `${_import.namespace}.useServer`);
+        }
+        for (let sp of _import.specifiers) {
+            if (sp.imported === "useServer") {
+                code = replacer(code, sp.local);
+            }
+        }
+    }
+    return codes.join("\n") + "\n" + code;
+};
+export default useServerReplacer;

package/dist/bin/bundler/client/watch.config.d.ts

@@ -0,0 +1,3 @@
+import { WatchOptions } from "rolldown";
+declare const ClientWatchConfig: (isDev?: boolean) => Promise<WatchOptions>;
+export default ClientWatchConfig;

package/dist/bin/bundler/client/watch.config.js

@@ -0,0 +1,39 @@
+import loadEnv from "../../include/loadEnv.js";
+import outdirs from "../../../outdirs.js";
+const ClientWatchConfig = async (isDev = false) => {
+    return {
+        output: {
+            dir: outdirs.client,
+            format: "esm",
+            sourcemap: isDev,
+            preserveModules: false,
+            chunkFileNames: isDev ? "chunks/[name].js" : "chunks/[hash]c.js",
+            assetFileNames: "assets/[name][extname]",
+            entryFileNames: "runtime.js",
+        },
+        treeshake: true,
+        tsconfig: true,
+        checks: {
+            moduleLevelDirective: false,
+        },
+        resolve: {
+            extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
+            conditionNames: ["browser", "import", "module", "default"],
+        },
+        transform: {
+            target: "es2022",
+            jsx: {
+                runtime: "automatic",
+                refresh: true,
+            },
+            define: await loadEnv({
+                mode: isDev ? "development" : "production",
+                isClient: true,
+            }),
+        },
+        watch: {
+            clearScreen: false,
+        },
+    };
+};
+export default ClientWatchConfig;

package/dist/bin/bundler/client/watch.d.ts

@@ -0,0 +1,13 @@
+import { type RolldownWatcher } from "rolldown";
+import { XanixClientEntry } from "../../types.js";
+type Option = {
+    onStart?: () => Promise<void>;
+    onChange?: (files: string[], duration: number, moduleToChunk: Map<string, string>, assets: Map<string, {
+        type: string;
+        path: string;
+        name: string;
+    }>) => Promise<void>;
+    onReady?: (duration: number, entries: XanixClientEntry[]) => Promise<void>;
+};
+declare const WatchClient: (options: Option) => Promise<RolldownWatcher>;
+export default WatchClient;

package/dist/bin/bundler/client/watch.js

@@ -0,0 +1,71 @@
+import { watch } from "rolldown";
+import ClientWatchConfig from "./watch.config.js";
+import { getManifest } from "../../include/manifest.js";
+import { frameworkDir, normalizePath } from "../../include/utils.js";
+import XanixCache from "../cache/index.js";
+import xanixAssets from "../../plugins/XanixAssets.js";
+import xanixTsconfigAlias from "../../plugins/XanixTsconfigAlias.js";
+import xanixDocument from "../../plugins/XanixDocument.js";
+import XanixTransformer from "./plugins/Transformer.js";
+import XanixPages from "./plugins/XanixPages.js";
+import path from "node:path";
+const WatchClient = async (options) => {
+    const entries = await getManifest();
+    const config = await ClientWatchConfig(true);
+    const changedFiles = new Set();
+    const moduleToChunk = new Map();
+    const assets = new Map();
+    let isReady = false;
+    let start = 0;
+    const watcher = watch({
+        ...config,
+        input: path.join(frameworkDir, "dist/client-runtime.js"),
+        plugins: [
+            XanixCache(),
+            XanixTransformer(),
+            xanixAssets(assets),
+            xanixTsconfigAlias(),
+            xanixDocument(),
+            XanixPages(),
+            {
+                name: "xanix-client",
+                async watchChange(id) {
+                    changedFiles.add(normalizePath(id));
+                },
+                async buildStart() {
+                    await options.onStart?.();
+                    start = performance.now();
+                },
+                async generateBundle(_options, bundle) {
+                    moduleToChunk.clear();
+                    for (const output of Object.values(bundle)) {
+                        if (output.type !== "chunk")
+                            continue;
+                        for (const id of Object.keys(output.modules)) {
+                            moduleToChunk.set(normalizePath(id), output.fileName);
+                        }
+                    }
+                    const duration = parseInt((performance.now() - start).toFixed(2));
+                    if (!isReady) {
+                        await options.onReady?.(duration, entries);
+                        isReady = true;
+                    }
+                    else {
+                        await options.onChange?.(Array.from(changedFiles), duration, moduleToChunk, assets);
+                    }
+                    changedFiles.clear();
+                },
+            },
+        ],
+    });
+    watcher.on("event", (event) => {
+        if (event.code === "ERROR") {
+            console.error("Build error:", event.error);
+        }
+        // if (event.code === "BUNDLE_END") {
+        //   console.log(event.duration);
+        // }
+    });
+    return watcher;
+};
+export default WatchClient;

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

@@ -0,0 +1,20 @@
+declare const loadEnv: ({ mode, isClient, }: {
+    mode: "development" | "production";
+    isClient: boolean;
+}) => Promise<{
+    "process.env.NODE_ENV": string;
+    __XANIX_PAGE_NAVIGATION_HEADER_VALUE__: string;
+    __XANIX_CLIENT_RUNTIME_FILE_NAME__: string;
+    __XANIX_CLIENT__: string;
+    __XANIX_SERVER__: string;
+    __XANIX_DEV__: string;
+    __XANIX_PROD__: string;
+    XANIX_NAVIGATE: string;
+    XANIX_NAVIGATE_START: string;
+    XANIX_NAVIGATE_END: string;
+    XANIX_NAVIGATE_RELOAD: string;
+    XANIX_PRELOAD: string;
+    XANIX_PRELOAD_START: string;
+    XANIX_PRELOAD_END: string;
+}>;
+export default loadEnv;

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

@@ -0,0 +1,48 @@
+import path from "node:path";
+import fs from "node:fs";
+import dotenv from "dotenv";
+import { getClientRuntimeFileName, uid } from "../../include/utils.js";
+const HEARDER_VALUE = uid(Math.random().toString(36), 32);
+const loadEnv = async ({ mode, isClient, }) => {
+    const root = process.cwd();
+    const publicPrefix = "PUBLIC_";
+    const envFiles = [
+        path.resolve(root, ".env"),
+        path.resolve(root, mode === "development" ? ".env.dev" : ".env.prod"),
+    ];
+    const env = {};
+    for (const file of envFiles) {
+        if (!fs.existsSync(file)) {
+            continue;
+        }
+        const result = dotenv.parse(fs.readFileSync(file));
+        Object.assign(env, result);
+    }
+    const clientEnv = {};
+    const serverEnv = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (key.startsWith(publicPrefix)) {
+            clientEnv[`process.env.${key}`] = JSON.stringify(value);
+        }
+        else {
+            serverEnv[`process.env.${key}`] = JSON.stringify(value);
+        }
+    }
+    return {
+        "process.env.NODE_ENV": JSON.stringify(mode),
+        __XANIX_PAGE_NAVIGATION_HEADER_VALUE__: JSON.stringify(HEARDER_VALUE),
+        __XANIX_CLIENT_RUNTIME_FILE_NAME__: JSON.stringify(getClientRuntimeFileName(mode)),
+        __XANIX_CLIENT__: isClient ? "true" : "false",
+        __XANIX_SERVER__: isClient ? "false" : "true",
+        __XANIX_DEV__: mode === "development" ? "true" : "false",
+        __XANIX_PROD__: mode === "production" ? "true" : "false",
+        XANIX_NAVIGATE: JSON.stringify("xanix:navigate"),
+        XANIX_NAVIGATE_START: JSON.stringify("xanix:navigate:start"),
+        XANIX_NAVIGATE_END: JSON.stringify("xanix:navigate:end"),
+        XANIX_NAVIGATE_RELOAD: JSON.stringify("xanix:navigate:reload"),
+        XANIX_PRELOAD: JSON.stringify("xanix:preload"),
+        XANIX_PRELOAD_START: JSON.stringify("xanix:preload:start"),
+        XANIX_PRELOAD_END: JSON.stringify("xanix:preload:end"),
+    };
+};
+export default loadEnv;

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

@@ -1,4 +1,4 @@
-import { OutputOptions } from "rollup";
+import { OutputOptions } from "rolldown";
 import { XanixClientEntry } from "../../types";
 type Options = {
     isDev?: boolean;