xanix 1.0.19 → 1.0.21

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

@@ -1,166 +0,0 @@
-import path from "node:path";
-import { rolldown } from "rolldown";
-import { createRequire } from "node:module";
-import { tsconfigPathsMatcher } from "../XanixTsconfigAlias.js";
-import fs from "node:fs";
-import loadEnv from "../../config/loadEnv.js";
-import { pathToFileURL } from "node:url";
-const require = createRequire(import.meta.url);
-const cacheDir = path.join(process.cwd(), ".xanix/cache");
-const cached = new Map();
-const makeFilename = (id) => id.replace(/[\/\\]/g, "-").replaceAll("@", "");
-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");
-};
-const resolveDependency = (id) => {
-    try {
-        return require.resolve(id);
-    }
-    catch {
-        // Try common extension substitutions.
-        const candidates = [
-            id.replace(/\.js$/, ".mjs"),
-            id.replace(/\.js$/, ".cjs"),
-            `${id}.mjs`,
-            `${id}.cjs`,
-        ];
-        for (const candidate of candidates) {
-            try {
-                return require.resolve(candidate);
-            }
-            catch { }
-        }
-        throw new Error(`Cannot resolve dependency: ${id}`);
-    }
-};
-const XanixCache = ({ cacheDir = "./.xanix/cache", define, }) => {
-    const dependencyMap = new Map();
-    const plugins = {
-        name: "XanixCache",
-        buildStart() {
-            dependencyMap.clear();
-        },
-        watchChange() {
-            dependencyMap.clear();
-        },
-        async resolveId(id) {
-            if (id.startsWith(".") ||
-                path.isAbsolute(id) ||
-                id === "virtual:xanix-document" ||
-                tsconfigPathsMatcher(id)) {
-                return null;
-            }
-            try {
-                let info = dependencyMap.get(id);
-                if (!info) {
-                    const resolved = resolveDependency(id);
-                    console.log(resolved);
-                    info = {
-                        filename: `${makeFilename(id)}.js`,
-                        code: await makeEsmShim(resolved),
-                        resolved,
-                    };
-                    dependencyMap.set(id, info);
-                }
-                return {
-                    id: `/.xanix/cache/${info.filename}`,
-                    external: true,
-                };
-            }
-            catch (error) { }
-            return null;
-        },
-        async generateBundle() {
-            const manifestPath = path.resolve(cacheDir, "cache-manifest.json");
-            const currentManifest = fs.existsSync(manifestPath)
-                ? JSON.parse(fs.readFileSync(manifestPath, "utf-8"))
-                : {};
-            let changed = false;
-            const inputs = {};
-            const manifest = {};
-            for (const id of dependencyMap.keys()) {
-                if (!currentManifest[id] ||
-                    currentManifest[id].resolved !== dependencyMap.get(id)?.resolved) {
-                    changed = true;
-                }
-                inputs[makeFilename(id)] = `dep:${id}`;
-                manifest[id] = {
-                    filename: dependencyMap.get(id)?.filename,
-                    resolved: dependencyMap.get(id)?.resolved,
-                };
-            }
-            if (!changed) {
-                return;
-            }
-            const bundle = await rolldown({
-                input: inputs,
-                treeshake: true,
-                tsconfig: true,
-                resolve: {
-                    extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
-                    conditionNames: ["browser", "import", "module", "default"],
-                },
-                transform: {
-                    target: "es2022",
-                    jsx: {
-                        runtime: "automatic",
-                    },
-                    define: await loadEnv({
-                        mode: "development",
-                        isClient: true,
-                    }),
-                },
-                plugins: [
-                    {
-                        name: "generate",
-                        resolveId(id) {
-                            if (id.startsWith("dep:")) {
-                                return id;
-                            }
-                            return null;
-                        },
-                        async load(id) {
-                            if (id.startsWith("dep:")) {
-                                const code = dependencyMap.get(id.replace("dep:", ""))?.code;
-                                return code;
-                            }
-                            return null;
-                        },
-                    },
-                ],
-            });
-            await bundle.write({
-                dir: cacheDir,
-                format: "esm",
-                exports: "auto",
-                sourcemap: true,
-                codeSplitting: true,
-                entryFileNames: `[name].js`,
-            });
-            await bundle.close();
-            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-        },
-    };
-    return plugins;
-};
-export default XanixCache;

package/dist/bin/bundler/plugins/XanixResolveCacheDeps-dep/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-dep/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-dep/index.d.ts

@@ -1,5 +0,0 @@
-import { XanixClientEntry } from "../../../types";
-import type { Plugin } from "rollup";
-import { CacheMetadata } from "./BuildClientCache.js";
-declare function XanixResolveCacheDeps(metadata: CacheMetadata, entries: XanixClientEntry[]): Plugin;
-export default XanixResolveCacheDeps;

package/dist/bin/bundler/plugins/XanixResolveCacheDeps-dep/index.js

@@ -1,26 +0,0 @@
-import path from "node:path";
-import BuildCache from "./BuildClientCache.js";
-import outdirs from "../../../../outdirs.js";
-function XanixResolveCacheDeps(metadata, entries) {
-    return {
-        name: "xanix:cached-deps",
-        async resolveId(source) {
-            if (source.startsWith(".") || path.isAbsolute(source)) {
-                return null;
-            }
-            const dependency = metadata.get(source);
-            if (dependency) {
-                return { id: `/${outdirs.cache}/${dependency.file}`, external: true };
-            }
-            const buildCache = await BuildCache(entries);
-            const newDependency = buildCache.get(source);
-            if (newDependency) {
-                return {
-                    id: `/${outdirs.cache}/${newDependency.file}`,
-                    external: true,
-                };
-            }
-        },
-    };
-}
-export default XanixResolveCacheDeps;

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

@@ -1,11 +0,0 @@
-import type { Plugin } from "rollup";
-export interface OxcResolverOptions {
-    extensions?: string[];
-    conditionNames?: string[];
-    mainFields?: string[];
-    aliasFields?: string[];
-    tsconfig?: string;
-    symlinks?: boolean;
-}
-declare function XanixResolver(options?: OxcResolverOptions): Plugin;
-export default XanixResolver;

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

@@ -1,55 +0,0 @@
-import { ResolverFactory } from "oxc-resolver";
-function XanixResolver(options = {}) {
-    const resolver = new ResolverFactory({
-        extensions: options.extensions ?? [
-            ".mjs",
-            ".js",
-            ".json",
-            ".ts",
-            ".tsx",
-            ".jsx",
-        ],
-        conditionNames: options.conditionNames ?? [
-            "node",
-            "import",
-            "module",
-            "default",
-        ],
-        mainFields: options.mainFields ?? ["module", "main"],
-        aliasFields: options.aliasFields ?? [],
-        symlinks: options.symlinks ?? true,
-        tsconfig: options.tsconfig
-            ? {
-                configFile: options.tsconfig,
-            }
-            : undefined,
-    });
-    return {
-        name: "xanix-oxc-resolver",
-        resolveId(source, importer, options) {
-            if (!importer) {
-                return null;
-            }
-            if (source.startsWith("\0") || source.startsWith("virtual:")) {
-                return null;
-            }
-            try {
-                const result = resolver.resolveFileSync(importer, source);
-                if (!result.path) {
-                    return null;
-                }
-                return {
-                    id: result.path,
-                    external: false,
-                };
-            }
-            catch {
-                if (options?.isEntry) {
-                    return null;
-                }
-                return null;
-            }
-        },
-    };
-}
-export default XanixResolver;

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

@@ -1,5 +0,0 @@
-import type { Plugin } from "rolldown";
-export interface XanixServerTransformOptions {
-    mode: "watch" | "start";
-}
-export default function XanixServerTransform(options: XanixServerTransformOptions): Plugin;

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

@@ -1,207 +0,0 @@
-const RUNTIME_IMPORT = "xanix/runtime";
-function isIdentifier(node, name) {
-    if (!node || node.type !== "Identifier") {
-        return false;
-    }
-    return name === undefined || node.name === name;
-}
-function isCallExpression(node) {
-    return node?.type === "CallExpression";
-}
-function isMemberExpression(node) {
-    return (node?.type === "MemberExpression" ||
-        node?.type === "OptionalMemberExpression");
-}
-function getMemberPropertyName(node) {
-    if (!isMemberExpression(node)) {
-        return null;
-    }
-    if (node.computed) {
-        if (node.property?.type === "Literal" &&
-            typeof node.property.value === "string") {
-            return node.property.value;
-        }
-        return null;
-    }
-    if (node.property?.type === "Identifier") {
-        return node.property.name;
-    }
-    return null;
-}
-function walk(node, callback, parent = null) {
-    callback(node, parent);
-    for (const key of Object.keys(node)) {
-        if (key === "parent" ||
-            key === "loc" ||
-            key === "range" ||
-            key === "tokens" ||
-            key === "comments") {
-            continue;
-        }
-        const value = node[key];
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (item && typeof item === "object") {
-                    if (typeof item.type === "string") {
-                        walk(item, callback, node);
-                    }
-                }
-            }
-            continue;
-        }
-        if (value && typeof value === "object" && typeof value.type === "string") {
-            walk(value, callback, node);
-        }
-    }
-}
-function findExpressServer(ast) {
-    const expressApps = new Map();
-    /*
-     * Find:
-     *
-     * const app = express();
-     */
-    walk(ast, (node) => {
-        if (node.type !== "VariableDeclarator") {
-            return;
-        }
-        if (!isIdentifier(node.id)) {
-            return;
-        }
-        if (!isCallExpression(node.init)) {
-            return;
-        }
-        if (!isIdentifier(node.init.callee, "express")) {
-            return;
-        }
-        expressApps.set(node.id.name, node);
-    });
-    if (!expressApps.size) {
-        return null;
-    }
-    /*
-     * Find:
-     *
-     * app.listen(...)
-     */
-    let result = null;
-    walk(ast, (node) => {
-        if (result) {
-            return;
-        }
-        if (node.type !== "CallExpression") {
-            return;
-        }
-        const callee = node.callee;
-        if (!isMemberExpression(callee)) {
-            return;
-        }
-        if (getMemberPropertyName(callee) !== "listen") {
-            return;
-        }
-        if (!isIdentifier(callee.object)) {
-            return;
-        }
-        const declarator = expressApps.get(callee.object.name);
-        if (!declarator) {
-            return;
-        }
-        result = {
-            appName: callee.object.name,
-            declarator,
-        };
-    });
-    return result;
-}
-function hasRuntimeImport(ast) {
-    for (const statement of ast.body ?? []) {
-        if (statement.type !== "ImportDeclaration") {
-            continue;
-        }
-        if (statement.source?.value !== RUNTIME_IMPORT) {
-            continue;
-        }
-        for (const specifier of statement.specifiers ?? []) {
-            if (specifier.type === "ImportSpecifier" &&
-                specifier.imported?.type === "Identifier" &&
-                specifier.imported.name === "createXanixServer") {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function createRuntimeImport(ast) {
-    if (hasRuntimeImport(ast)) {
-        return "";
-    }
-    return `import { createXanixServer } from "${RUNTIME_IMPORT}";\n`;
-}
-function getLanguage(id) {
-    const file = id.split("?")[0];
-    if (file.endsWith(".tsx")) {
-        return "tsx";
-    }
-    if (file.endsWith(".ts")) {
-        return "ts";
-    }
-    if (file.endsWith(".jsx")) {
-        return "jsx";
-    }
-    return "js";
-}
-export default function XanixServerTransform(options) {
-    return {
-        name: "xanix-server-transform",
-        transform: {
-            filter: {
-                id: /^(?!.*(?:node_modules[\\/])).*\.[cm]?[jt]sx?$/,
-            },
-            handler(code, id) {
-                /*
-                 * IMPORTANT:
-                 *
-                 * This is Rolldown's parser.
-                 * No Babel parser.
-                 */
-                let ast;
-                try {
-                    ast = this.parse(code, {
-                        lang: getLanguage(id),
-                    });
-                }
-                catch {
-                    return null;
-                }
-                const server = findExpressServer(ast);
-                if (!server) {
-                    return null;
-                }
-                const init = server.declarator.init;
-                if (!init ||
-                    !isCallExpression(init) ||
-                    !isIdentifier(init.callee, "express")) {
-                    return null;
-                }
-                if (init.start == null || init.end == null) {
-                    return null;
-                }
-                const replacement = `createXanixServer({ mode: ${JSON.stringify(options.mode)} })`;
-                /*
-                 * We only need one source replacement.
-                 *
-                 * If you're using Rolldown native MagicString,
-                 * perform the overwrite there.
-                 */
-                const importCode = createRuntimeImport(ast);
-                const before = code.slice(0, init.start);
-                const after = code.slice(init.end);
-                const transformed = importCode + before + replacement + after;
-                return {
-                    code: transformed,
-                    map: null,
-                };
-            },
-        },
-    };
-}

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

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

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

@@ -1,23 +0,0 @@
-import { transform } from "oxc-transform";
-function xanixTransform() {
-    return {
-        name: "xanix-transform",
-        async transform(code, id) {
-            if (!id.endsWith(".tsx")) {
-                return null;
-            }
-            const result = await transform(id, code, {
-                lang: "tsx",
-                sourcemap: true,
-                jsx: {
-                    runtime: "automatic",
-                },
-            });
-            return {
-                code: result.code,
-                map: result.map,
-            };
-        },
-    };
-}
-export default xanixTransform;

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

@@ -1,19 +0,0 @@
-import type { Plugin } from "rolldown";
-/**
- * Check whether an import matches a tsconfig path alias.
- *
- * Examples:
- *
- * @db
- * @db/index
- * @db/user
- *
- * with:
- *
- * "@db/*": ["./src/db/*"]
- */
-export declare function tsconfigPathsMatcher(id: string): boolean;
-/**
- * Rollup plugin.
- */
-export default function xanixTsconfigAlias(): Plugin;