xanix 1.0.19 → 1.0.21

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

@@ -1,170 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import { getClientRuntimeFile } from "../../include/utils.js";
-const root = process.cwd();
-function getLanguage(id) {
-    const filename = id.split("?")[0];
-    if (filename.endsWith(".tsx")) {
-        return "tsx";
-    }
-    if (filename.endsWith(".ts")) {
-        return "ts";
-    }
-    if (filename.endsWith(".jsx")) {
-        return "jsx";
-    }
-    return "js";
-}
-function isReactComponent(name) {
-    return /^[A-Z][A-Za-z0-9_$]*$/.test(name);
-}
-function walk(node, callback) {
-    if (!node || typeof node !== "object") {
-        return;
-    }
-    if (Array.isArray(node)) {
-        for (const child of node) {
-            walk(child, callback);
-        }
-        return;
-    }
-    const current = node;
-    callback(current);
-    for (const key of Object.keys(current)) {
-        if (key === "parent" ||
-            key === "loc" ||
-            key === "range" ||
-            key === "tokens" ||
-            key === "comments") {
-            continue;
-        }
-        const value = current[key];
-        if (value && typeof value === "object") {
-            walk(value, callback);
-        }
-    }
-}
-function collectRegistrations(program, filename) {
-    const registrations = [];
-    walk(program, (node) => {
-        if (node.type === "FunctionDeclaration") {
-            const id = node.id;
-            if (!id || id.type !== "Identifier" || !id.name) {
-                return;
-            }
-            const name = id.name;
-            if (!isReactComponent(name)) {
-                return;
-            }
-            registrations.push(createRegistration(name, filename));
-            return;
-        }
-        if (node.type !== "VariableDeclarator") {
-            return;
-        }
-        const id = node.id;
-        const init = node.init;
-        if (!id || id.type !== "Identifier" || !id.name) {
-            return;
-        }
-        if (!init) {
-            return;
-        }
-        if (init.type !== "ArrowFunctionExpression" &&
-            init.type !== "FunctionExpression") {
-            return;
-        }
-        const name = id.name;
-        if (!isReactComponent(name)) {
-            return;
-        }
-        registrations.push(createRegistration(name, filename));
-    });
-    return registrations;
-}
-function createRegistration(name, filename) {
-    const relative = path
-        .relative(root, filename.split("?")[0])
-        .replaceAll("\\", "/");
-    const componentId = `${relative}:${name}`;
-    return `$RefreshReg$(${name}, ${JSON.stringify(componentId)});`;
-}
-export default function xanixReactRefresh(webSocketPort) {
-    return {
-        name: "xanix-react-refresh",
-        load(id) {
-            if (path.resolve(id) !== getClientRuntimeFile()) {
-                return null;
-            }
-            const code = fs.readFileSync(id, "utf8");
-            const refreshCode = `
-
-import RefreshRuntime from "react-refresh/runtime";
-RefreshRuntime.injectIntoGlobalHook(window);
-window.$RefreshReg$ = (type, id) => {
-  RefreshRuntime.register(type, id);
-};
-window.$RefreshSig$ = () => (type) => type;
-
-const ws = new WebSocket(
-  ${JSON.stringify(`ws://localhost:${49152}`)}
-);
-
-ws.onmessage = async (event) => {
-  const files = JSON.parse(event.data);
-
-  for (const file of files) {
-    if (!file.endsWith(".js")) {
-      continue;
-    }
-    const url =
-      getImportUrl(
-        file.replace(/\.js$/, "")
-      ) +
-      "?t=" +
-      Date.now();
-
-    await import(url);
-  }
-
-  RefreshRuntime.performReactRefresh();
-
-  ws.send("reload");
-};
-${code}
-
-`;
-            return {
-                code: refreshCode,
-                map: null,
-            };
-        },
-        transform: {
-            filter: {
-                id: /^(?!.*node_modules[\\/]).*\.[cm]?[jt]sx?$/,
-            },
-            handler(code, id) {
-                const resolvedId = path.resolve(id);
-                if (resolvedId === getClientRuntimeFile()) {
-                    return null;
-                }
-                const filename = id.split("?")[0];
-                if (!/\.(tsx?|jsx?)$/.test(filename)) {
-                    return null;
-                }
-                const program = this.parse(code, {
-                    lang: getLanguage(filename),
-                });
-                const registrations = collectRegistrations(program, filename);
-                if (registrations.length === 0) {
-                    return null;
-                }
-                const registrationCode = `\n\n${registrations.join("\n")}\n`;
-                return {
-                    code: code + registrationCode,
-                    map: null,
-                };
-            },
-        },
-    };
-}

package/dist/bin/bundler/plugins/XanixResolveCacheDeps/BuildClientCache.d.ts

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

package/dist/bin/bundler/plugins/XanixResolveCacheDeps/BuildClientCache.js

@@ -1,129 +0,0 @@
-import path from "node:path";
-import { rollup } from "rollup";
-import { build } from "esbuild";
-import { builtinModules, createRequire } from "node:module";
-import { getClientRuntimeFile } from "../../../include/utils.js";
-import outdirs from "../../../../outdirs.js";
-import { xanixCachePlugins } from "../plugins.js";
-import defines from "../../config/defines.js";
-import { pathToFileURL } from "node:url";
-import external from "../../config/external.js";
-const require = createRequire(import.meta.url);
-const nodeBuiltins = new Set(builtinModules.flatMap((id) => [id, `node:${id}`]));
-const GenerateGraph = async (entries) => {
-    const collector = new Map();
-    const input = [];
-    for (const entry of entries) {
-        input.push(entry.file);
-    }
-    input.push(getClientRuntimeFile());
-    const bundle = await rollup({
-        input,
-        plugins: [...xanixCachePlugins()],
-        external(id) {
-            if (nodeBuiltins.has(id)) {
-                return true;
-            }
-            if (!external(id)) {
-                return false;
-            }
-            collector.set(id, {
-                source: id,
-                resolved: require.resolve(id, {
-                    paths: [process.cwd()],
-                }),
-                packageName: id,
-            });
-            return true;
-        },
-    });
-    await bundle.close();
-    return collector;
-};
-// Wraps each CJS dep in a virtual ESM file that re-exports named exports detected via require()
-const makeCjsWrapperPlugin = (wrappers) => ({
-    name: "cjs-named-exports",
-    setup(build) {
-        build.onResolve({ filter: /\?cjs-wrapper$/ }, (args) => ({
-            path: args.path,
-            namespace: "cjs-wrapper",
-        }));
-        build.onLoad({ filter: /.*/, namespace: "cjs-wrapper" }, (args) => {
-            const contents = wrappers.get(args.path);
-            return { contents, resolveDir: process.cwd() };
-        });
-    },
-});
-const buildWrappers = async (input) => {
-    const wrappers = new Map();
-    const wrappedInput = {};
-    for (const [name, resolved] of Object.entries(input)) {
-        const key = `${name}?cjs-wrapper`;
-        let namedExports = [];
-        let hasDefault = false;
-        try {
-            // Node: inspect the actual module
-            const mod = await import(pathToFileURL(resolved).href);
-            hasDefault =
-                mod &&
-                    (typeof mod === "object" || typeof mod === "function") &&
-                    "default" in mod;
-            namedExports = Object.keys(mod).filter((key) => key !== "__esModule" && key !== "default");
-        }
-        catch (err) {
-            console.log(`Failed to inspect ${name}:`, err);
-        }
-        // esbuild: use a normal filesystem path
-        const lines = [`import * as __mod from ${JSON.stringify(resolved)};`];
-        if (hasDefault) {
-            lines.push(`export default __mod.default;`);
-        }
-        else {
-            lines.push(`export default __mod;`);
-        }
-        for (const exportName of namedExports) {
-            if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
-                lines.push(`export const ${exportName} = __mod[${JSON.stringify(exportName)}];`);
-            }
-        }
-        wrappers.set(key, lines.join("\n"));
-        wrappedInput[name] = key;
-    }
-    return {
-        wrappers,
-        wrappedInput,
-    };
-};
-const bundleDeps = async (input, outdir) => {
-    const { wrappers, wrappedInput } = await buildWrappers(input);
-    await build({
-        entryPoints: wrappedInput,
-        bundle: true,
-        splitting: true,
-        format: "esm",
-        target: "es2022",
-        outdir,
-        entryNames: "[name]",
-        chunkNames: "chunks/[hash]",
-        platform: "browser",
-        sourcemap: true,
-        define: defines({ mode: "development", isClient: true }),
-        plugins: [makeCjsWrapperPlugin(wrappers)],
-    });
-};
-// const metadata: CacheMetadata = new Map();
-const BuildClientCache = async (entries, metadata = new Map()) => {
-    const input = {};
-    const dependencies = await GenerateGraph(entries);
-    for (const dependency of dependencies.values()) {
-        const entryName = dependency.source.replace(/^@/, "").replace(/\//g, "-");
-        input[entryName] = dependency.resolved;
-        metadata.set(dependency.source, {
-            file: `${entryName}.js`,
-        });
-    }
-    const cacheDir = path.resolve(outdirs.server, "cache");
-    await bundleDeps(input, cacheDir);
-    return metadata;
-};
-export default BuildClientCache;

package/dist/bin/bundler/plugins/XanixResolveCacheDeps/index copy.d.ts

@@ -1,15 +0,0 @@
-import { type Plugin } from "rolldown";
-export type CacheDepsPluginOptions = {
-    /** Directory where built dependency bundles + manifest.json are written. */
-    cacheDir: string;
-    /** Return true for ids that should be pulled from the dep cache instead of bundled inline. */
-    isExternal: (id: string) => boolean;
-    /** URL prefix the dev server serves cacheDir under. Default "/__cache__/". */
-    publicPath?: string;
-    /** esbuild-style define map applied when building each cached dep. */
-    define?: Record<string, string>;
-    /** Log every resolveId decision to the console. Use temporarily to diagnose why nothing's caching. */
-    debug?: boolean;
-};
-export declare const cacheDepsPlugin: (options: CacheDepsPluginOptions) => Plugin;
-export default cacheDepsPlugin;

package/dist/bin/bundler/plugins/XanixResolveCacheDeps/index copy.js

@@ -1,228 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import crypto from "node:crypto";
-import { rolldown } from "rolldown";
-import { builtinModules, createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-const require = createRequire(import.meta.url);
-const nodeBuiltins = new Set(builtinModules.flatMap((id) => [id, `node:${id}`]));
-const readManifest = (cacheDir) => {
-    const file = path.join(cacheDir, "manifest.json");
-    try {
-        return JSON.parse(fs.readFileSync(file, "utf8"));
-    }
-    catch {
-        return {};
-    }
-};
-const writeManifest = (cacheDir, manifest) => {
-    fs.mkdirSync(cacheDir, { recursive: true });
-    fs.writeFileSync(path.join(cacheDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-};
-// Cheap, fast fingerprint: mtime + size of the resolved entry file.
-const fingerprint = (resolved) => {
-    const stat = fs.statSync(resolved);
-    return `${stat.size}-${stat.mtimeMs}`;
-};
-const entryNameFor = (source) => source.replace(/^@/, "").replace(/\//g, "-");
-// Ids owned by other plugins: virtual modules (foo:bar convention), rollup's
-// null-byte convention (\0foo), or anything else that isn't a real bare npm
-// specifier. require.resolve() can never find these on disk — don't try.
-const isVirtualId = (id) => id.startsWith("\0") || /^[a-zA-Z][\w+.-]*:/.test(id);
-// Inspects the resolved CJS/ESM module and generates a small ESM shim that
-// re-exports its default + named exports, so rolldown always sees a clean ESM entry.
-const makeEsmShim = async (resolved) => {
-    let namedExports = [];
-    let hasDefault = false;
-    try {
-        const mod = await import(pathToFileURL(resolved).href);
-        hasDefault =
-            mod &&
-                (typeof mod === "object" || typeof mod === "function") &&
-                "default" in mod;
-        namedExports = Object.keys(mod).filter((key) => key !== "__esModule" && key !== "default");
-    }
-    catch (err) {
-        console.warn(`[cache-deps] failed to inspect ${resolved}:`, err);
-    }
-    const lines = [`import * as __mod from ${JSON.stringify(resolved)};`];
-    lines.push(hasDefault ? `export default __mod.default;` : `export default __mod;`);
-    for (const exportName of namedExports) {
-        if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(exportName)) {
-            lines.push(`export const ${exportName} = __mod[${JSON.stringify(exportName)}];`);
-        }
-    }
-    return lines.join("\n");
-};
-/**
- * Builds and resolves cached dependency bundles for a rolldown build.
- *
- * Key property: when a cached package itself imports another package that
- * `isExternal` also matches (e.g. a UI lib importing "react"), that nested
- * import is NOT inlined into the package's bundle. It's resolved through
- * this same cache, so every consumer — the app and every cached dep alike —
- * shares exactly one built copy of "react". That's what prevents duplicate-
- * React ("Invalid hook call" / "Cannot read properties of null (reading
- * 'useContext')") bugs.
- */
-class DepCache {
-    constructor(cacheDir, isExternal, define, publicPath) {
-        this.cacheDir = cacheDir;
-        this.isExternal = isExternal;
-        this.define = define;
-        this.publicPath = publicPath;
-        this.inflight = new Map();
-        this.building = new Set();
-        fs.mkdirSync(cacheDir, { recursive: true });
-        this.manifest = readManifest(cacheDir);
-    }
-    /** Resolves `source` (imported from `importerDir`) to a cache filename, building if needed.
-     *  Returns null if `source` isn't resolvable as a real filesystem module (e.g. a virtual id
-     *  another plugin owns) — caller should defer to the rest of the plugin chain in that case. */
-    resolveFile(source, importerDir) {
-        let p = this.inflight.get(source);
-        if (!p) {
-            p = this.build(source, importerDir);
-            this.inflight.set(source, p);
-        }
-        return p;
-    }
-    async build(source, importerDir) {
-        let resolved;
-        try {
-            resolved = require.resolve(source, { paths: [importerDir] });
-        }
-        catch {
-            return null; // not a real module on disk — not ours to handle
-        }
-        const key = fingerprint(resolved);
-        const cached = this.manifest[source];
-        if (cached &&
-            cached.key === key &&
-            fs.existsSync(path.join(this.cacheDir, cached.file))) {
-            return cached.file;
-        }
-        const entryName = entryNameFor(source);
-        const hash = crypto
-            .createHash("sha1")
-            .update(resolved + key)
-            .digest("hex")
-            .slice(0, 8);
-        const file = `${entryName}.${hash}.js`;
-        const outFile = path.join(this.cacheDir, file);
-        // Guard against circular "cached package A imports cached package B
-        // imports A" — fall back to inlining on the cycle edge instead of
-        // deadlocking on inflight promises.
-        const isCycle = this.building.has(source);
-        this.building.add(source);
-        try {
-            await this.bundle(source, resolved, outFile, !isCycle);
-        }
-        catch (err) {
-            console.error(`[cache-deps] failed to build "${source}" (${resolved}) — falling back to inline bundling:`, err);
-            return null; // don't kill the whole build; let rolldown bundle it normally
-        }
-        finally {
-            this.building.delete(source);
-        }
-        this.manifest[source] = { source, resolved, file, key };
-        writeManifest(this.cacheDir, this.manifest);
-        return file;
-    }
-    async bundle(source, resolved, outFile, dedupeExternals) {
-        const shimId = `\0cache-deps-shim:${source}`;
-        const shimCode = await makeEsmShim(resolved);
-        const depDir = path.dirname(resolved);
-        const plugin = {
-            name: "cache-deps-shim",
-            resolveId: async (id) => {
-                if (id === shimId)
-                    return shimId;
-                if (id.startsWith(".") || id.startsWith("/") || path.isAbsolute(id)) {
-                    return null; // let rolldown resolve relative/internal files of the package normally
-                }
-                if (nodeBuiltins.has(id)) {
-                    return { id, external: true };
-                }
-                if (isVirtualId(id)) {
-                    return null;
-                }
-                if (dedupeExternals && this.isExternal(id)) {
-                    // Route to the shared cache entry instead of bundling a second copy.
-                    const file = await this.resolveFile(id, depDir);
-                    if (file === null)
-                        return null;
-                    return { id: this.publicPath + file, external: true };
-                }
-                return null; // inline this transitive dep (not shared/singleton)
-            },
-            load(id) {
-                if (id === shimId)
-                    return shimCode;
-                return null;
-            },
-        };
-        const bundle = await rolldown({
-            input: shimId,
-            platform: "browser",
-            transform: {
-                target: "es2022",
-                jsx: {
-                    runtime: "automatic",
-                },
-                define: this.define,
-            },
-            plugins: [plugin],
-        });
-        await bundle.write({
-            file: outFile,
-            format: "esm",
-            sourcemap: true,
-        });
-        await bundle.close();
-    }
-}
-export const cacheDepsPlugin = (options) => {
-    const { cacheDir, isExternal, define, debug = false } = options;
-    const publicPath = options.publicPath ?? "/__cache__/";
-    const cache = new DepCache(cacheDir, isExternal, define, publicPath);
-    const log = (...args) => {
-        if (debug)
-            console.log("[cache-deps]", ...args);
-    };
-    log("initialized, cacheDir =", cacheDir);
-    return {
-        name: "xanix-cache-deps",
-        async resolveId(source, importer) {
-            if (!importer) {
-                log("skip (entry point):", source);
-                return null; // entry points aren't deps
-            }
-            if (source.startsWith(".") ||
-                source.startsWith("/") ||
-                path.isAbsolute(source)) {
-                return null; // relative/absolute — too noisy to log every one of these
-            }
-            if (nodeBuiltins.has(source)) {
-                return { id: source, external: true };
-            }
-            if (isVirtualId(source)) {
-                log("skip (virtual id):", source);
-                return null; // owned by another plugin (virtual:, \0, etc.) — don't touch it
-            }
-            if (!isExternal(source)) {
-                log("skip (isExternal() = false):", source);
-                return null; // let it bundle normally into the main output
-            }
-            log("caching:", source, "from", importer);
-            const file = await cache.resolveFile(source, path.dirname(importer));
-            if (file === null) {
-                log("build failed, falling back to inline:", source);
-                return null; // couldn't resolve as a real module — defer to others
-            }
-            log("cached ->", file);
-            return { id: publicPath + file, external: true };
-        },
-    };
-};
-export default cacheDepsPlugin;

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

@@ -1,7 +0,0 @@
-import { type Plugin } from "rolldown";
-export type XanixCacheOptions = {
-    cacheDir?: string;
-    define?: Record<string, any>;
-};
-declare const XanixCache: ({ cacheDir, define, }: XanixCacheOptions) => Plugin;
-export default XanixCache;