xanix 1.0.20 → 1.0.21

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

@@ -1,103 +0,0 @@
-import { rolldown } from "rolldown";
-import { walk } from "oxc-walker";
-import TransformExpress from "./TransformExpress.js";
-import TransformPage from "./TransformPage.js";
-import loadEnv from "../../config/loadEnv.js";
-import { getClientRuntimeFile, getClientRuntimeFileName, } from "../../../include/utils.js";
-import { xanixDefaultPlugins } from "../plugins.js";
-import bundlerOutput from "../../config/output.js";
-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 XanixTransform = () => {
-    let entries = [];
-    return {
-        name: "xanix-transform",
-        async transform(code, id) {
-            if (id.includes("node_modules")) {
-                return null;
-            }
-            const lang = getParserLanguage(id);
-            if (lang !== "tsx" && lang !== "jsx") {
-                return null;
-            }
-            const ast = this.parse(code, { lang });
-            const transformExpress = new TransformExpress();
-            const transformPage = new TransformPage();
-            walk(ast, {
-                enter(node) {
-                    transformExpress.transform(node);
-                    transformPage.transform(node);
-                },
-            });
-            let replacements = [
-                ...transformExpress.replacements,
-                ...transformPage.replacements,
-            ];
-            for (let entry of transformPage.entries) {
-                const resolved = await this.resolve(entry.source, id, {
-                    skipSelf: true,
-                });
-                entry.resolved = resolved?.id ?? "";
-                entries.push(entry);
-            }
-            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() {
-            const input = {};
-            for (let entry of entries) {
-                input[entry.name] = entry.resolved;
-            }
-            const runtimeFileName = getClientRuntimeFileName("development");
-            input[runtimeFileName] = getClientRuntimeFile();
-            const build = await rolldown({
-                input,
-                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: "development",
-                        isClient: true,
-                    }),
-                },
-                plugins: [
-                    ...xanixDefaultPlugins({
-                        WebSocketPort: 3000,
-                        target: "client",
-                        development: true,
-                        assetExternal: true,
-                    }),
-                ],
-            });
-            await build.write(bundlerOutput.client(entries, { isDev: true }));
-            await build.close();
-        },
-    };
-};
-export default XanixTransform;

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

@@ -1,5 +0,0 @@
-import type { Plugin } from "rolldown";
-export interface XanixAssetsOptions {
-    emit?: boolean;
-}
-export default function xanixAssets(options?: XanixAssetsOptions): Plugin;

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

@@ -1,51 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import crypto from "node:crypto";
-const ASSET_RE = /\.(png|jpe?g|gif|svg|webp|avif|ico|bmp|mp4|webm|ogg|mp3|wav|woff2?|ttf|otf)$/i;
-export default function xanixAssets(options = {}) {
-    const emit = options.emit ?? true;
-    return {
-        name: "xanix-assets",
-        resolveId(source, importer) {
-            if (!importer) {
-                return null;
-            }
-            if (!ASSET_RE.test(source)) {
-                return null;
-            }
-            if (source.startsWith(".") || source.startsWith("/")) {
-                return path.resolve(path.dirname(importer), source);
-            }
-            return null;
-        },
-        load(id) {
-            if (!ASSET_RE.test(id)) {
-                return null;
-            }
-            if (!fs.existsSync(id)) {
-                return null;
-            }
-            const source = fs.readFileSync(id);
-            const ext = path.extname(id);
-            const basename = path.basename(id, ext);
-            const hash = crypto
-                .createHash("sha256")
-                .update(source)
-                .digest("hex")
-                .slice(0, 8);
-            const fileName = `${basename}-${hash}${ext}`;
-            if (emit) {
-                this.emitFile({
-                    type: "asset",
-                    name: fileName,
-                    originalFileName: id,
-                    source,
-                });
-            }
-            return {
-                code: `export default ${JSON.stringify(fileName)};`,
-                moduleSideEffects: false,
-            };
-        },
-    };
-}

package/dist/bin/bundler/plugins/XanixCacheDeps-dep.d.ts

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

package/dist/bin/bundler/plugins/XanixCacheDeps-dep.js

@@ -1,150 +0,0 @@
-import path from "node:path";
-import { createRequire } from "node:module";
-import { rollup } from "rollup";
-import outdirs from "../../../outdirs.js";
-import XanixEnvPlugin from "./XanixEnv.js";
-import nodeResolve from "@rollup/plugin-node-resolve";
-import commonjs from "@rollup/plugin-commonjs";
-import json from "@rollup/plugin-json";
-import XanixDocument from "./XanixDocument/index.js";
-import esbuild from "rollup-plugin-esbuild";
-import defines from "../config/defines.js";
-import fs from "node:fs";
-import { pathToFileURL } from "node:url";
-const require = createRequire(import.meta.url);
-const cacheDir = outdirs.cache;
-const filename = (source) => source.replace(/^@/, "").replace(/\//g, "-");
-const cached = new Map();
-function resolveFrom(source, fromDir) {
-    return require.resolve(source, { paths: [fromDir] });
-}
-async function getRealExportedKeys(resolvedEntry) {
-    try {
-        const mod = await import(pathToFileURL(resolvedEntry).href);
-        const hasDefault = mod &&
-            (typeof mod === "object" || typeof mod === "function") &&
-            "default" in mod;
-        const names = Object.keys(mod).filter((key) => key !== "__esModule" && key !== "default");
-        return { modules: names, hasDefault };
-    }
-    catch {
-        return { modules: [], hasDefault: false }; // native ESM or require failure — no shim possible/needed
-    }
-}
-/**
- * Marks a dependency's transitive deps external using their BARE specifier
- * (e.g. "react", not "./react.js"). This lets @rollup/plugin-commonjs
- * resolve them normally via node resolution for its interop/named-exports
- * shim — resolving a real bare specifier always succeeds, unlike resolving
- * a synthetic relative path that doesn't exist on disk. The actual path
- * rewrite to "./react.js" happens afterward via output.paths, not here.
- */
-const resolver = (externalsUsed) => {
-    return {
-        name: "xanix-cache-deps-resolver",
-        async resolveId(source, importer) {
-            if (source.startsWith(".") || path.isAbsolute(source)) {
-                return null;
-            }
-            const fromDir = importer ? path.dirname(importer) : process.cwd();
-            let resolved;
-            try {
-                resolved = resolveFrom(source, fromDir);
-            }
-            catch {
-                return null;
-            }
-            await bundleCache(source, resolved);
-            externalsUsed.add(source);
-            // Bare id, external — commonjs plugin can resolve this for real.
-            return { id: source, external: true };
-        },
-    };
-};
-const bundleCache = (source, resolvedEntry) => {
-    if (cached.has(source))
-        return cached.get(source);
-    const promise = (async () => {
-        const file = filename(source);
-        const input = resolvedEntry ?? resolveFrom(source, process.cwd());
-        const externalsUsed = new Set();
-        const isClient = true;
-        const mode = "development";
-        const build = await rollup({
-            input,
-            plugins: [
-                resolver(externalsUsed),
-                XanixEnvPlugin({ mode, isClient }),
-                nodeResolve({
-                    browser: isClient,
-                    preferBuiltins: !isClient,
-                    extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
-                }),
-                commonjs(),
-                json(),
-                XanixDocument(),
-                esbuild({
-                    target: isClient ? "es2022" : "node20",
-                    jsx: "automatic",
-                    tsconfig: false,
-                    define: defines({ mode, isClient }),
-                }),
-            ],
-        });
-        const paths = {};
-        for (const dep of externalsUsed) {
-            paths[dep] = `./${filename(dep)}.js`;
-        }
-        await build.write({
-            dir: cacheDir,
-            format: "esm",
-            entryFileNames: `${file}.internal.js`,
-            exports: "named",
-            paths,
-        });
-        const { modules, hasDefault } = await getRealExportedKeys(resolvedEntry ?? input);
-        const lines = [`import __mod from './${file}.internal.js';`];
-        if (hasDefault) {
-            lines.push(`export default __mod.default;`);
-        }
-        else {
-            lines.push(`export default __mod;`);
-        }
-        for (const exportName of modules) {
-            if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
-                lines.push(`export const ${exportName} = __mod[${JSON.stringify(exportName)}] || __mod.default[${JSON.stringify(exportName)}]`);
-            }
-        }
-        await fs.promises.writeFile(path.join(cacheDir, `${file}.js`), lines.join("\n") + "\n", "utf8");
-    })();
-    cached.set(source, promise);
-    return promise;
-};
-export default function XanixCachedDeps() {
-    return {
-        name: "xanix-cache-deps",
-        async resolveId(source, importer) {
-            if (source.startsWith(".") || path.isAbsolute(source)) {
-                return null;
-            }
-            const fromDir = importer ? path.dirname(importer) : process.cwd();
-            let resolved;
-            try {
-                resolved = resolveFrom(source, fromDir);
-            }
-            catch {
-                return null;
-            }
-            await bundleCache(source, resolved);
-            // Same principle applies here if this outer build also runs through
-            // a commonjs plugin: prefer returning a bare-style external id and
-            // supplying `paths` on the OUTER build's output config (in
-            // WatchClient / bundlerOutput.client) rather than baking "../cache/x.js"
-            // directly into the id.
-            return {
-                id: `/${outdirs.cache}/${filename(source)}.js`,
-                external: true,
-            };
-        },
-    };
-}

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

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

package/dist/bin/bundler/plugins/XanixCacheDeps.js

@@ -1,150 +0,0 @@
-import path from "node:path";
-import { createRequire } from "node:module";
-import { rollup } from "rollup";
-import outdirs from "../../../outdirs.js";
-import XanixEnvPlugin from "./XanixEnv.js";
-import nodeResolve from "@rollup/plugin-node-resolve";
-import commonjs from "@rollup/plugin-commonjs";
-import json from "@rollup/plugin-json";
-import XanixDocument from "./XanixDocument/index.js";
-import esbuild from "rollup-plugin-esbuild";
-import defines from "../config/defines.js";
-import fs from "node:fs";
-import { pathToFileURL } from "node:url";
-const require = createRequire(import.meta.url);
-const cacheDir = outdirs.cache;
-const filename = (source) => source.replace(/^@/, "").replace(/\//g, "-");
-const cached = new Map();
-function resolveFrom(source, fromDir) {
-    return require.resolve(source, { paths: [fromDir] });
-}
-async function getRealExportedKeys(resolvedEntry) {
-    try {
-        const mod = await import(pathToFileURL(resolvedEntry).href);
-        const hasDefault = mod &&
-            (typeof mod === "object" || typeof mod === "function") &&
-            "default" in mod;
-        const names = Object.keys(mod).filter((key) => key !== "__esModule" && key !== "default");
-        return { modules: names, hasDefault };
-    }
-    catch {
-        return { modules: [], hasDefault: false }; // native ESM or require failure — no shim possible/needed
-    }
-}
-/**
- * Marks a dependency's transitive deps external using their BARE specifier
- * (e.g. "react", not "./react.js"). This lets @rollup/plugin-commonjs
- * resolve them normally via node resolution for its interop/named-exports
- * shim — resolving a real bare specifier always succeeds, unlike resolving
- * a synthetic relative path that doesn't exist on disk. The actual path
- * rewrite to "./react.js" happens afterward via output.paths, not here.
- */
-const resolver = (externalsUsed) => {
-    return {
-        name: "xanix-cache-deps-resolver",
-        async resolveId(source, importer) {
-            if (source.startsWith(".") || path.isAbsolute(source)) {
-                return null;
-            }
-            const fromDir = importer ? path.dirname(importer) : process.cwd();
-            let resolved;
-            try {
-                resolved = resolveFrom(source, fromDir);
-            }
-            catch {
-                return null;
-            }
-            await bundleCache(source, resolved);
-            externalsUsed.add(source);
-            // Bare id, external — commonjs plugin can resolve this for real.
-            return { id: source, external: true };
-        },
-    };
-};
-const bundleCache = (source, resolvedEntry) => {
-    if (cached.has(source))
-        return cached.get(source);
-    const promise = (async () => {
-        const file = filename(source);
-        const input = resolvedEntry ?? resolveFrom(source, process.cwd());
-        const externalsUsed = new Set();
-        const isClient = true;
-        const mode = "development";
-        const build = await rollup({
-            input,
-            plugins: [
-                resolver(externalsUsed),
-                XanixEnvPlugin({ mode, isClient }),
-                nodeResolve({
-                    browser: isClient,
-                    preferBuiltins: !isClient,
-                    extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
-                }),
-                commonjs(),
-                json(),
-                XanixDocument(),
-                esbuild({
-                    target: isClient ? "es2022" : "node20",
-                    jsx: "automatic",
-                    tsconfig: false,
-                    define: defines({ mode, isClient }),
-                }),
-            ],
-        });
-        const paths = {};
-        for (const dep of externalsUsed) {
-            paths[dep] = `./${filename(dep)}.js`;
-        }
-        await build.write({
-            dir: cacheDir,
-            format: "esm",
-            entryFileNames: `${file}.internal.js`,
-            exports: "named",
-            paths,
-        });
-        const { modules, hasDefault } = await getRealExportedKeys(resolvedEntry ?? input);
-        const lines = [`import __mod from './${file}.internal.js';`];
-        if (hasDefault) {
-            lines.push(`export default __mod.default;`);
-        }
-        else {
-            lines.push(`export default __mod;`);
-        }
-        for (const exportName of modules) {
-            if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
-                lines.push(`export const ${exportName} = __mod[${JSON.stringify(exportName)}] || __mod.default[${JSON.stringify(exportName)}]`);
-            }
-        }
-        await fs.promises.writeFile(path.join(cacheDir, `${file}.js`), lines.join("\n") + "\n", "utf8");
-    })();
-    cached.set(source, promise);
-    return promise;
-};
-export default function XanixCachedDeps() {
-    return {
-        name: "xanix-cache-deps",
-        async resolveId(source, importer) {
-            if (source.startsWith(".") || path.isAbsolute(source)) {
-                return null;
-            }
-            const fromDir = importer ? path.dirname(importer) : process.cwd();
-            let resolved;
-            try {
-                resolved = resolveFrom(source, fromDir);
-            }
-            catch {
-                return null;
-            }
-            await bundleCache(source, resolved);
-            // Same principle applies here if this outer build also runs through
-            // a commonjs plugin: prefer returning a bare-style external id and
-            // supplying `paths` on the OUTER build's output config (in
-            // WatchClient / bundlerOutput.client) rather than baking "../cache/x.js"
-            // directly into the id.
-            return {
-                id: `/${outdirs.cache}/${filename(source)}.js`,
-                external: true,
-            };
-        },
-    };
-}

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

@@ -1,53 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const VIRTUAL_ID = "virtual:xanix-document";
-const RESOLVED_ID = "\0virtual:xanix-document";
-export default function xanixDocument() {
-    const root = process.cwd();
-    const userDocument = path.resolve(root, "document.tsx");
-    const baseDocument = require.resolve("../../../../../dist/components/BaseDocument.js");
-    return {
-        name: "xanix-document",
-        resolveId(id) {
-            if (id === VIRTUAL_ID) {
-                return RESOLVED_ID;
-            }
-            return null;
-        },
-        load(id) {
-            if (id !== RESOLVED_ID) {
-                return null;
-            }
-            const documentFile = fs.existsSync(userDocument)
-                ? userDocument
-                : baseDocument;
-            const source = fs.readFileSync(documentFile, "utf8");
-            const hasMetadata = /\bexport\s+(?:const|let|var|function|class)\s+metadata\b/.test(source) || /\bexport\s*\{[^}]*\bmetadata\b[^}]*\}/.test(source);
-            const importPath = path.resolve(documentFile).replaceAll("\\", "/");
-            if (hasMetadata) {
-                return {
-                    code: `
-import Document, * as DocumentModule from ${JSON.stringify(importPath)};
-
-export const metadata = DocumentModule.metadata;
-
-export default Document;
-`,
-                    map: null,
-                };
-            }
-            return {
-                code: `
-import Document from ${JSON.stringify(importPath)};
-
-export const metadata = async () => ({});
-
-export default Document;
-`,
-                map: null,
-            };
-        },
-    };
-}

package/dist/bin/bundler/plugins/XanixEntryFinder/finder.d.ts

@@ -1,11 +0,0 @@
-import * as t from "@babel/types";
-import { XanixClientEntry } from "../../../types";
-export declare function resolveFile(file: string): string;
-export declare function resolveComponentFile(importer: string, importPath: string): string;
-export declare function createClientId(file: string): string;
-export declare function getJSXComponentName(node: t.JSXElement): string | null;
-export declare function findComponentImport(ast: t.File, componentName: string): {
-    file: string;
-    export: string;
-} | null;
-export declare function entryFinder(code: string, id: string): XanixClientEntry[];

package/dist/bin/bundler/plugins/XanixEntryFinder/finder.js

@@ -1,149 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import crypto from "node:crypto";
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import * as t from "@babel/types";
-import { normalizePath } from "../../../include/utils.js";
-const SOURCE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
-export function resolveFile(file) {
-    const absolute = path.resolve(file);
-    if (fs.existsSync(absolute)) {
-        const stat = fs.statSync(absolute);
-        if (stat.isFile()) {
-            return absolute;
-        }
-    }
-    for (const ext of SOURCE_EXTENSIONS) {
-        const candidate = `${absolute}${ext}`;
-        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-            return path.resolve(candidate);
-        }
-    }
-    if (fs.existsSync(absolute) && fs.statSync(absolute).isDirectory()) {
-        for (const ext of SOURCE_EXTENSIONS) {
-            const candidate = path.join(absolute, `index${ext}`);
-            if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
-                return path.resolve(candidate);
-            }
-        }
-    }
-    return absolute;
-}
-export function resolveComponentFile(importer, importPath) {
-    if (!importPath.startsWith(".")) {
-        return importPath;
-    }
-    const base = path.resolve(path.dirname(importer), importPath);
-    return resolveFile(base);
-}
-export function createClientId(file) {
-    return `c_${crypto
-        .createHash("sha256")
-        .update(path.normalize(file))
-        .digest("hex")
-        .slice(0, 12)}`;
-}
-export function getJSXComponentName(node) {
-    const name = node.openingElement.name;
-    if (t.isJSXIdentifier(name)) {
-        return name.name;
-    }
-    if (t.isJSXMemberExpression(name)) {
-        if (t.isJSXIdentifier(name.object) && t.isJSXIdentifier(name.property)) {
-            return `${name.object.name}.${name.property.name}`;
-        }
-    }
-    return null;
-}
-export function findComponentImport(ast, componentName) {
-    for (const node of ast.program.body) {
-        if (!t.isImportDeclaration(node)) {
-            continue;
-        }
-        for (const specifier of node.specifiers) {
-            if (t.isImportDefaultSpecifier(specifier) &&
-                specifier.local.name === componentName) {
-                return {
-                    file: node.source.value,
-                    export: "default",
-                };
-            }
-            if (t.isImportSpecifier(specifier) &&
-                specifier.local.name === componentName) {
-                const imported = specifier.imported;
-                return {
-                    file: node.source.value,
-                    export: t.isIdentifier(imported) ? imported.name : imported.value,
-                };
-            }
-        }
-    }
-    return null;
-}
-export function entryFinder(code, id) {
-    const ast = parse(code, {
-        sourceType: "module",
-        plugins: ["typescript", "jsx"],
-    });
-    const entries = new Map();
-    traverse(ast, {
-        CallExpression(callPath) {
-            const call = callPath.node;
-            /*
-             * Find:
-             *
-             * res.send(<Home />);
-             */
-            if (!t.isMemberExpression(call.callee)) {
-                return;
-            }
-            if (!t.isIdentifier(call.callee.property, {
-                name: "send",
-            })) {
-                return;
-            }
-            const argument = call.arguments[0];
-            if (!argument || !t.isJSXElement(argument)) {
-                return;
-            }
-            const functionPath = callPath.getFunctionParent();
-            if (!functionPath) {
-                return;
-            }
-            const params = functionPath.node.params;
-            if (params.length < 2) {
-                return;
-            }
-            const requestParam = params[0];
-            const responseParam = params[1];
-            if (!t.isIdentifier(requestParam) || !t.isIdentifier(responseParam)) {
-                return;
-            }
-            const componentName = getJSXComponentName(argument);
-            if (!componentName) {
-                return;
-            }
-            const componentImport = findComponentImport(ast, componentName);
-            if (!componentImport) {
-                return;
-            }
-            const componentImportPath = componentImport.file;
-            const componentFile = resolveComponentFile(id, componentImportPath);
-            if (!path.isAbsolute(componentFile)) {
-                return;
-            }
-            const normalizedFile = normalizePath(componentFile);
-            const clientId = createClientId(normalizedFile);
-            const entry = {
-                id: clientId,
-                name: componentName,
-                file: normalizedFile,
-                path: componentImportPath,
-                export: componentImport.export,
-            };
-            entries.set(clientId, entry);
-        },
-    });
-    return Array.from(entries.values());
-}