xanix 1.0.20 → 1.0.21

package/dist/bin/bundler/requireCache.js

@@ -1,85 +0,0 @@
-const xanixCacheImports = () => {
-    return {
-        name: "xanix-cache-imports",
-        transform(code, id) {
-            console.log("[xanix-cache-imports]", id);
-            if (!code.includes("xanix-cache/")) {
-                return null;
-            }
-            console.log("[FOUND]", id);
-            const importRegex = /import\s+([\s\S]*?)\s+from\s+["'](xanix-cache\/[^"']+|\/xanix-cache\/[^"']+)["']\s*;?/g;
-            let changed = false;
-            const output = code.replace(importRegex, (_match, specifiers, source) => {
-                changed = true;
-                const normalizedSource = source.startsWith("/")
-                    ? source
-                    : `/${source}`;
-                const requireName = `_require_${source
-                    .replace(/^\/?xanix-cache\//, "")
-                    .replace(/\.[^/.]+$/, "")
-                    .replace(/[^a-zA-Z0-9_$]/g, "_")}`;
-                const value = specifiers.trim();
-                // import { jsx, jsxs } from "xanix-cache/react-jsx-runtime.js"
-                if (value.startsWith("{")) {
-                    const content = value
-                        .slice(1, -1)
-                        .split(",")
-                        .map((item) => item.trim())
-                        .filter(Boolean)
-                        .map((item) => {
-                        const parts = item.split(/\s+as\s+/);
-                        if (parts.length === 2) {
-                            return `${parts[0]}: ${parts[1]}`;
-                        }
-                        return parts[0];
-                    })
-                        .join(", ");
-                    return [
-                        `const ${requireName} = __require("${normalizedSource}");`,
-                        `const { ${content} } = ${requireName};`,
-                    ].join("\n");
-                }
-                // import * as React from "xanix-cache/react.js"
-                if (value.startsWith("* as ")) {
-                    const name = value.slice(5).trim();
-                    return `const ${name} = __require("${normalizedSource}");`;
-                }
-                // import React, { useState } from "..."
-                const defaultNamed = value.match(/^([A-Za-z_$][\w$]*)\s*,\s*\{([\s\S]*)\}$/);
-                if (defaultNamed) {
-                    const defaultName = defaultNamed[1];
-                    const named = defaultNamed[2]
-                        .split(",")
-                        .map((item) => item.trim())
-                        .filter(Boolean)
-                        .map((item) => {
-                        const parts = item.split(/\s+as\s+/);
-                        if (parts.length === 2) {
-                            return `${parts[0]}: ${parts[1]}`;
-                        }
-                        return parts[0];
-                    })
-                        .join(", ");
-                    return [
-                        `const ${requireName} = __require("${normalizedSource}");`,
-                        `const ${defaultName} = ${requireName}.default;`,
-                        `const { ${named} } = ${requireName};`,
-                    ].join("\n");
-                }
-                // import React from "..."
-                return [
-                    `const ${requireName} = __require("${normalizedSource}");`,
-                    `const ${value} = ${requireName}.default;`,
-                ].join("\n");
-            });
-            if (!changed) {
-                return null;
-            }
-            return {
-                code: output,
-                map: null,
-            };
-        },
-    };
-};
-export default xanixCacheImports;

package/dist/bin/bundler/server/plugins/ServerAction.d.ts

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

package/dist/bin/bundler/server/plugins/ServerAction.js

@@ -1,9 +0,0 @@
-const ServerAction = () => {
-    return {
-        name: "server-action",
-        async transform(source, id) {
-            // Implement your transformation logic here
-        },
-    };
-};
-export default ServerAction;

package/dist/bin/bundler/server/plugins/Transformer/ServerAction.d.ts

@@ -1,11 +0,0 @@
-declare class TransformServerAction {
-    replacements: {
-        start: number;
-        end: number;
-        value: string;
-    }[];
-    code: string;
-    constructor(code: string);
-    transform(node: any): void;
-}
-export default TransformServerAction;

package/dist/bin/bundler/server/plugins/Transformer/ServerAction.js

@@ -1,28 +0,0 @@
-import crypto from "node:crypto";
-class TransformServerAction {
-    constructor(code) {
-        this.replacements = [];
-        this.code = code;
-    }
-    transform(node) {
-        if (node.type === "CallExpression" &&
-            node.callee.name === "server" &&
-            node.arguments.length === 1 &&
-            (node.arguments[0].type === "ArrowFunctionExpression" ||
-                node.arguments[0].type === "FunctionExpression")) {
-            const fnNode = node.arguments[0];
-            const fnString = this.code.slice(fnNode.start, fnNode.end);
-            const id = crypto
-                .createHash("sha256")
-                .update(fnString)
-                .digest("hex")
-                .slice(0, 12);
-            this.replacements.push({
-                start: fnNode.end,
-                end: fnNode.end,
-                value: `"${id}"`,
-            });
-        }
-    }
-}
-export default TransformServerAction;

package/dist/bin/bundler/server/plugins/Transformer/TransformExpress copy.d.ts

@@ -1,11 +0,0 @@
-declare class TransformExpress {
-    replacements: {
-        start: number;
-        end: number;
-        value: string;
-    }[];
-    code: string;
-    constructor(code: string);
-    transform(node: any): void;
-}
-export default TransformExpress;

package/dist/bin/bundler/server/plugins/Transformer/TransformExpress copy.js

@@ -1,22 +0,0 @@
-class TransformExpress {
-    constructor(code) {
-        this.replacements = [];
-        this.code = code;
-    }
-    transform(node) {
-        if (node.type === "CallExpression" &&
-            node.callee.name === "server" &&
-            node.arguments.length === 1 &&
-            (node.arguments[0].type === "ArrowFunctionExpression" ||
-                node.arguments[0].type === "FunctionExpression")) {
-            const fnNode = node.arguments[0];
-            const fnString = this.code.slice(fnNode.start, fnNode.end);
-            this.replacements.push({
-                start: node.arguments[0].start + 1,
-                end: node.arguments[0].end - 1,
-                value: "xanix/express",
-            });
-        }
-    }
-}
-export default TransformExpress;

package/dist/bin/bundler/server/plugins/Transformer/TransformExpress.d.ts

@@ -1,10 +0,0 @@
-declare class TransformExpress {
-    replacements: {
-        start: number;
-        end: number;
-        value: string;
-    }[];
-    foundServer: boolean;
-    transform(node: any): void;
-}
-export default TransformExpress;

package/dist/bin/bundler/server/plugins/Transformer/TransformExpress.js

@@ -1,19 +0,0 @@
-class TransformExpress {
-    constructor() {
-        this.replacements = [];
-        this.foundServer = false;
-    }
-    transform(node) {
-        if (node.type === "CallExpression" &&
-            node.callee.type === "Identifier" &&
-            node.callee.name === "express") {
-            this.foundServer = true;
-            this.replacements.push({
-                start: node.start,
-                end: node.end,
-                value: `xanix("express")`,
-            });
-        }
-    }
-}
-export default TransformExpress;

package/dist/bin/bundler/server/plugins/Transformer/TransformReactContext.d.ts

@@ -1,17 +0,0 @@
-type Replacement = {
-    start: number;
-    end: number;
-    value: string;
-};
-export declare class TransformReactContext {
-    private readonly reactNamespaces;
-    private readonly createContextBindings;
-    readonly replacements: Replacement[];
-    transform(node: any): void;
-    private detectReactImport;
-    private detectReactRequire;
-    private isReactRequire;
-    private detectCreateContext;
-    private replaceCallee;
-}
-export default TransformReactContext;

package/dist/bin/bundler/server/plugins/Transformer/TransformReactContext.js

@@ -1,101 +0,0 @@
-export class TransformReactContext {
-    constructor() {
-        this.reactNamespaces = new Set();
-        this.createContextBindings = new Set();
-        this.replacements = [];
-    }
-    transform(node) {
-        this.detectReactImport(node);
-        this.detectReactRequire(node);
-        this.detectCreateContext(node);
-    }
-    detectReactImport(node) {
-        if (node.type !== "ImportDeclaration" || node.source?.value !== "react") {
-            return;
-        }
-        for (const specifier of node.specifiers) {
-            // import React from "react"
-            if (specifier.type === "ImportDefaultSpecifier") {
-                this.reactNamespaces.add(specifier.local.name);
-                continue;
-            }
-            // import * as React from "react"
-            if (specifier.type === "ImportNamespaceSpecifier") {
-                this.reactNamespaces.add(specifier.local.name);
-                continue;
-            }
-            // import { createContext } from "react"
-            // import { createContext as ctx } from "react"
-            if (specifier.type === "ImportSpecifier" &&
-                specifier.imported?.name === "createContext") {
-                this.createContextBindings.add(specifier.local.name);
-            }
-        }
-    }
-    detectReactRequire(node) {
-        if (node.type !== "VariableDeclarator") {
-            return;
-        }
-        if (!this.isReactRequire(node.init)) {
-            return;
-        }
-        // const React = require("react")
-        if (node.id.type === "Identifier") {
-            this.reactNamespaces.add(node.id.name);
-            return;
-        }
-        // const { createContext } = require("react")
-        // const { createContext: ctx } = require("react")
-        if (node.id.type === "ObjectPattern") {
-            for (const property of node.id.properties) {
-                if (property.type !== "Property" || property.computed) {
-                    continue;
-                }
-                if (property.key.type === "Identifier" &&
-                    property.key.name === "createContext") {
-                    const local = property.value.type === "Identifier" ? property.value.name : null;
-                    if (local) {
-                        this.createContextBindings.add(local);
-                    }
-                }
-            }
-        }
-    }
-    isReactRequire(node) {
-        return (node?.type === "CallExpression" &&
-            node.callee?.type === "Identifier" &&
-            node.callee.name === "require" &&
-            node.arguments?.length === 1 &&
-            node.arguments[0]?.type === "Literal" &&
-            node.arguments[0].value === "react");
-    }
-    detectCreateContext(node) {
-        if (node.type !== "CallExpression") {
-            return;
-        }
-        // createContext(...)
-        // createCtx(...)
-        if (node.callee.type === "Identifier" &&
-            this.createContextBindings.has(node.callee.name)) {
-            this.replaceCallee(node.callee);
-            return;
-        }
-        // React.createContext(...)
-        if (node.callee.type === "MemberExpression" &&
-            !node.callee.computed &&
-            node.callee.object.type === "Identifier" &&
-            node.callee.property.type === "Identifier" &&
-            node.callee.property.name === "createContext" &&
-            this.reactNamespaces.has(node.callee.object.name)) {
-            this.replaceCallee(node.callee);
-        }
-    }
-    replaceCallee(callee) {
-        this.replacements.push({
-            start: callee.start,
-            end: callee.end,
-            value: "__xanix.createContext",
-        });
-    }
-}
-export default TransformReactContext;

package/dist/bin/bundler/server/plugins/Transformer/TransformServerAction copy.d.ts

@@ -1,14 +0,0 @@
-declare class TransformServerAction {
-    replacements: {
-        start: number;
-        end: number;
-        value: string;
-    }[];
-    code: string;
-    serverImported: boolean;
-    importer: string;
-    count: number;
-    constructor(code: string, importer: string);
-    transform(node: any): void;
-}
-export default TransformServerAction;

package/dist/bin/bundler/server/plugins/Transformer/TransformServerAction copy.js

@@ -1,38 +0,0 @@
-import crypto from "node:crypto";
-class TransformServerAction {
-    constructor(code, importer) {
-        this.replacements = [];
-        this.serverImported = false;
-        this.count = 0;
-        this.code = code;
-        this.importer = importer;
-    }
-    transform(node) {
-        // check server imported
-        if (node.type === "ImportDeclaration" &&
-            node.source.value === "xanix" &&
-            node.specifiers.some((s) => s.type === "ImportSpecifier" && s.imported.name === "server")) {
-            this.serverImported = true;
-        }
-        if (node.type === "CallExpression" &&
-            node.callee.type === "Identifier" &&
-            node.callee.name === "server" &&
-            node.arguments.length === 1 &&
-            (node.arguments[0].type === "ArrowFunctionExpression" ||
-                node.arguments[0].type === "FunctionExpression")) {
-            const fnNode = node.arguments[0];
-            const fnString = this.code.slice(fnNode.start, fnNode.end);
-            const id = crypto
-                .createHash("sha256")
-                .update(this.importer + this.count++)
-                .digest("hex")
-                .slice(0, 12);
-            this.replacements.push({
-                start: node.start,
-                end: node.end,
-                value: `server(${fnString}, "${id}")`,
-            });
-        }
-    }
-}
-export default TransformServerAction;

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

@@ -1,5 +0,0 @@
-export type WatcherOptions = {
-    rootEntry: string;
-    onChange: (files: string[], duration: number) => Promise<void>;
-    onReady: (duration: number) => Promise<void>;
-};

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

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

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

@@ -1,12 +0,0 @@
-import { type RolldownWatcher } from "rolldown";
-import { XanixClientEntry } from "../types.js";
-type Option = {
-    onChange?: (files: string[], duration: number) => void;
-    onBuildEnd?: (duration: number) => void;
-    onReady?: () => Promise<void>;
-    onCachedStart?: () => void;
-    onCachedEnd?: () => void;
-    WebSocketPort: number;
-};
-declare const WatchClient: (entries: XanixClientEntry[], options: Option) => Promise<RolldownWatcher>;
-export default WatchClient;

package/dist/bin/bundler/watchClient.js

@@ -1,104 +0,0 @@
-import { watch } from "rolldown";
-import bundlerOutput from "./config/output.js";
-import fs from "node:fs";
-import { getClientRuntimeFile, getClientRuntimeFileName, normalizePath, } from "../include/utils.js";
-import { xanixDefaultPlugins } from "./plugins/plugins.js";
-import outdirs from "../../outdirs.js";
-import loadEnv from "./config/loadEnv.js";
-import XanixCache from "./cache/index.js";
-const WatchClient = async (entries, options) => {
-    const input = {};
-    for (const entry of entries) {
-        input[entry.name] = entry.file;
-    }
-    const runtimeFileName = getClientRuntimeFileName("development");
-    input[runtimeFileName] = getClientRuntimeFile();
-    fs.rmSync(outdirs.client, {
-        recursive: true,
-        force: true,
-    });
-    fs.mkdirSync(outdirs.client, {
-        recursive: true,
-    });
-    // options.onCachedStart?.();
-    // let clientCache = await BuildClientCache(entries);
-    // options.onCachedEnd?.();
-    let watchingMode = false;
-    const watcher = watch({
-        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: [
-            // externalResolver(),
-            XanixCache(),
-            ...xanixDefaultPlugins({
-                WebSocketPort: options.WebSocketPort,
-                target: "client",
-                development: true,
-                assetExternal: true,
-            }),
-        ],
-        output: bundlerOutput.client(entries, { isDev: true }),
-        watch: {
-            clearScreen: false,
-        },
-    });
-    let isReady = false;
-    const changedFiles = new Set();
-    watcher.on("change", (entry) => {
-        entry = normalizePath(entry);
-        const root = process.cwd();
-        const _entry = entries.find((e) => e.file === entry);
-        let buildFile = _entry
-            ? `${_entry.id}.js`
-            : entry
-                .replace(normalizePath(root), "")
-                .replace(/\.(ts|tsx|jsx)$/, ".js")
-                .replace(/^\\/, "");
-        changedFiles.add(buildFile);
-    });
-    let duration = 0;
-    watcher.on("event", async (event) => {
-        switch (event.code) {
-            case "BUNDLE_START":
-                break;
-            case "BUNDLE_END":
-                duration = event.duration;
-                options.onBuildEnd?.(event.duration);
-                break;
-            case "END":
-                if (changedFiles.size && options.onChange) {
-                    options.onChange(Array.from(changedFiles), duration);
-                    changedFiles.clear();
-                }
-                if (!isReady) {
-                    isReady = true;
-                    await options.onReady?.();
-                }
-                break;
-            case "ERROR":
-                console.error("[client]", event.error);
-                break;
-        }
-    });
-    return watcher;
-};
-export default WatchClient;

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

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

package/dist/bin/bundler/watchServer.js

@@ -1,139 +0,0 @@
-import { watch } from "rolldown";
-import path from "node:path";
-import fs from "node:fs";
-import { getEntries } from "../include/manifest.js";
-import bundlerOutput from "./config/output.js";
-import { entriesEqual } from "../include/entry.js";
-import { xanixDefaultPlugins } from "./plugins/plugins.js";
-import outdirs from "../../outdirs.js";
-import { normalizePath } from "../include/utils.js";
-import loadEnv from "./config/loadEnv.js";
-import { builtinModules } from "node:module";
-import { tsconfigPathsMatcher } from "./plugins/XanixTsconfigAlias.js";
-import XanixTransform from "./plugins/TransformServer/index.js";
-import { ResolverFactory } from "rolldown/experimental";
-const resolver = new ResolverFactory();
-const root = process.cwd();
-const nodeBuiltins = new Set(builtinModules);
-function isNodeBuiltin(id) {
-    const normalized = id.startsWith("node:") ? id.slice(5) : id;
-    return nodeBuiltins.has(normalized);
-}
-const watchServer = async ({ rootEntry, onChange, onBuildEnd, onClientEntryChange, onReady, }) => {
-    fs.rmSync(outdirs.server, {
-        recursive: true,
-        force: true,
-    });
-    fs.mkdirSync(outdirs.server, {
-        recursive: true,
-    });
-    const input = {
-        index: path.resolve(root, rootEntry),
-    };
-    const watcher = watch({
-        input,
-        treeshake: true,
-        platform: "node",
-        tsconfig: true,
-        checks: {
-            moduleLevelDirective: false,
-        },
-        resolve: {
-            extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
-            conditionNames: ["node", "import", "module", "default"],
-        },
-        transform: {
-            target: "node20",
-            jsx: {
-                runtime: "automatic",
-            },
-            define: await loadEnv({
-                mode: "development",
-                isClient: false,
-            }),
-        },
-        plugins: [
-            XanixTransform(),
-            ...xanixDefaultPlugins({
-                target: "server",
-                development: true,
-                assetExternal: false,
-            }),
-        ],
-        external(id, parent) {
-            if (id.startsWith(".") ||
-                path.isAbsolute(id) ||
-                id.startsWith("xanix") ||
-                id === "virtual:xanix-document" ||
-                tsconfigPathsMatcher(id)) {
-                return false;
-            }
-            if (isNodeBuiltin(id)) {
-                return true;
-            }
-            if (parent) {
-                const resolve = resolver.sync(path.dirname(parent), id);
-                if (resolve.path) {
-                    const ext = path.extname(resolve.path);
-                    const valid = [".js", ".cjs", ".mjs"];
-                    if (!valid.includes(ext)) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        },
-        output: bundlerOutput.server({
-            isDev: true,
-        }),
-        watch: {
-            clearScreen: false,
-        },
-    });
-    let isReady = false;
-    const changedFiles = new Set();
-    watcher.on("change", async (id) => {
-        changedFiles.add(normalizePath(id));
-    });
-    let duration = 0;
-    watcher.on("event", async (event) => {
-        switch (event.code) {
-            case "BUNDLE_END": {
-                duration = event.duration;
-                onBuildEnd?.(event.duration);
-                break;
-            }
-            case "END": {
-                const entries = await getEntries();
-                if (changedFiles.size) {
-                    if (entries.length) {
-                        const clientEntries = Array.from(entries);
-                        for (const entry of changedFiles) {
-                            const isClientEntry = clientEntries.find((e) => e.file === entry);
-                            if (!isClientEntry) {
-                                const currentEntries = await getEntries();
-                                const isEqual = await entriesEqual(currentEntries);
-                                if (!isEqual) {
-                                    await onClientEntryChange?.(entry, currentEntries);
-                                }
-                            }
-                        }
-                    }
-                    await onChange?.(Array.from(changedFiles).map((file) => file.replace(normalizePath(root), "")), duration);
-                    changedFiles.clear();
-                }
-                if (!isReady) {
-                    isReady = true;
-                    await onReady?.(entries);
-                }
-                break;
-            }
-            case "ERROR": {
-                console.error("[server]", event.error);
-                break;
-            }
-        }
-    });
-    return watcher;
-};
-export default watchServer;

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

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