xanix 1.0.20 → 1.0.21

package/dist/bin/bundler/cache/buildCache.js

@@ -4,7 +4,7 @@ import outdirs from "../../../outdirs.js";
 const VIRTUAL_PREFIX = "\0xanix-cache:";
 const buildCache = async (cached) => {
     const input = {};
-    for (const [source, { name }] of cached) {
+    for (const [, { name }] of cached) {
         input[name] = `${VIRTUAL_PREFIX}${name}`;
     }
     const build = await rolldown({
@@ -49,18 +49,16 @@ const buildCache = async (cached) => {
                     }
                     const resolved = cache.resolved || cache.module;
                     if (cache.default) {
-                        return `
-import * as __xanix_namespace from ${JSON.stringify(resolved)};
-
-export default __xanix_namespace.default;
-export { __xanix_namespace };
+                        return `
+import * as __xmod from ${JSON.stringify(resolved)};
+export default __xmod.default;
+export { __xmod };
 `;
                     }
-                    return `
-import * as __xanix_namespace from ${JSON.stringify(resolved)};
-
-export default __xanix_namespace;
-export { __xanix_namespace };
+                    return `
+import * as __xmod from ${JSON.stringify(resolved)};
+export default __xmod;
+export { __xmod };
 `;
                 },
             },

package/dist/bin/bundler/cache/index.js

@@ -1,27 +1,16 @@
 import { createRequire } from "node:module";
-import { isPackageImport, makeFilename } from "./utils.js";
+import { isPackageImport, makeFilename, readManifest, writeManifest, } from "./utils.js";
 import buildCache from "./buildCache.js";
-import { walk } from "oxc-walker";
 import { builtinModules } from "node:module";
-import { readManifest, writeManifest } from "./manifest.js";
 import logger from "../../include/logger.js";
 import pc from "picocolors";
+import findImports from "../../finder/findImports.js";
 const nodeBuiltins = new Set(builtinModules);
 function isNodeBuiltin(id) {
     const normalized = id.startsWith("node:") ? id.slice(5) : id;
     return nodeBuiltins.has(normalized);
 }
 const require = createRequire(import.meta.url);
-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";
-}
 function makeImportName(name) {
     return `require_${name.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
 }
@@ -30,12 +19,6 @@ const XanixCache = () => {
     let init = false;
     return {
         name: "__xmod",
-        buildStart() {
-            cached.clear();
-        },
-        watchChange() {
-            cached.clear();
-        },
         async resolveId(source) {
             if (source.startsWith("/__xmod")) {
                 return {
@@ -52,102 +35,68 @@ const XanixCache = () => {
             if (!code.includes("import ") && !code.includes("import(")) {
                 return null;
             }
-            const lang = getParserLanguage(id);
-            const ast = this.parse(code, { lang });
             const packages = [];
             let replacements = [];
-            walk(ast, {
-                enter(node) {
-                    if (node.type !== "ImportDeclaration" || node.importKind === "type") {
-                        return;
-                    }
-                    const source = node.source.value;
-                    if (typeof source !== "string" ||
-                        !isPackageImport(source) ||
-                        isNodeBuiltin(source)) {
-                        return;
-                    }
-                    /*
-                     * Don't add the same package multiple times
-                     * when the file imports it more than once.
-                     */
-                    if (!packages.includes(source)) {
-                        packages.push(source);
-                    }
-                    const name = makeFilename(source);
-                    const importName = makeImportName(name);
-                    const cachePath = `/__xmod/${name}.js`;
-                    const lines = [];
-                    const specifiers = (node.specifiers ?? []).filter((specifier) => specifier.importKind !== "type");
-                    if (!specifiers.length) {
-                        lines.push(`import "${cachePath}";`);
-                    }
-                    else {
-                        const defaultSpecifier = specifiers.find((specifier) => specifier.type === "ImportDefaultSpecifier");
-                        const namespaceSpecifier = specifiers.find((specifier) => specifier.type === "ImportNamespaceSpecifier");
-                        const namedSpecifiers = specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
-                        /*
-                         * Only import default when the original import
-                         * actually has a default import.
-                         */
-                        if (defaultSpecifier) {
-                            lines.push(`import ${importName} from "${cachePath}";`);
-                            lines.push(`const ${defaultSpecifier.local.name} = ${importName};`);
-                        }
-                        /*
-                         * Namespace and named imports use the Xanix
-                         * namespace export.
-                         */
-                        if (namespaceSpecifier || namedSpecifiers.length) {
-                            const namespaceName = `${importName}_ns`;
-                            lines.push(`import { __xanix_namespace as ${namespaceName} } from "${cachePath}";`);
-                            if (namespaceSpecifier) {
-                                lines.push(`const ${namespaceSpecifier.local.name} = ${namespaceName};`);
-                            }
-                            if (namedSpecifiers.length) {
-                                const properties = namedSpecifiers
-                                    .map((specifier) => {
-                                    const imported = specifier.imported?.type === "Identifier"
-                                        ? specifier.imported.name
-                                        : specifier.imported?.value;
-                                    const local = specifier.local?.name;
-                                    if (!imported || !local) {
-                                        return null;
-                                    }
-                                    if (imported !== local) {
-                                        if (typeof imported === "string" &&
-                                            !/^[$A-Z_a-z][$\w]*$/.test(imported)) {
-                                            return `${JSON.stringify(imported)}: ${local}`;
-                                        }
-                                        return `${imported}: ${local}`;
-                                    }
-                                    return imported;
-                                })
-                                    .filter(Boolean)
-                                    .join(", ");
-                                if (properties) {
-                                    lines.push(`const { ${properties} } = ${namespaceName};`);
-                                }
-                            }
-                        }
-                    }
-                    if (!cached.has(source)) {
-                        cached.set(source, {
-                            module: source,
-                            name,
-                            resolved: "",
-                            exports: [],
-                            default: false,
-                        });
-                    }
-                    replacements.push({
-                        source,
-                        start: node.start,
-                        end: node.end,
-                        value: lines.join("\n"),
+            let counter = 0;
+            for (const imp of findImports(code)) {
+                if (imp.typeOnly)
+                    continue;
+                const source = imp.source;
+                if (!isPackageImport(source) || isNodeBuiltin(source))
+                    continue;
+                /*
+                 * Don't add the same package multiple times
+                 * when the file imports it more than once.
+                 */
+                if (!packages.includes(source)) {
+                    packages.push(source);
+                }
+                const name = makeFilename(source);
+                const cachePath = `/__xmod/${name}.js`;
+                const named = imp.named.filter((s) => !s.typeOnly);
+                /*
+                 * Unique per import statement (require_react, require_react1, ...)
+                 * so the same package imported twice never redeclares a binding.
+                 */
+                const local = `${makeImportName(name)}${counter++ || ""}`;
+                const mod = `_${local}`; // `import * as` keeps this name in the bundle
+                const ns = `${mod}.__xmod`;
+                const bindings = [];
+                if (imp.default)
+                    bindings.push(local);
+                if (imp.namespace || named.length)
+                    bindings.push(`* as ${mod}`);
+                const lines = [
+                    bindings.length
+                        ? `import ${bindings.join(", ")} from "${cachePath}";`
+                        : `import "${cachePath}";`,
+                ];
+                if (imp.default)
+                    lines.push(`const ${imp.default} = ${local};`);
+                if (imp.namespace)
+                    lines.push(`const ${imp.namespace} = ${ns};`);
+                if (named.length) {
+                    const props = named
+                        .map(({ imported, local }) => imported !== local ? `${imported}: ${local}` : imported)
+                        .join(", ");
+                    lines.push(`const { ${props} } = ${ns};`);
+                }
+                if (!cached.has(source)) {
+                    cached.set(source, {
+                        module: source,
+                        name,
+                        resolved: "",
+                        exports: [],
+                        default: false,
                     });
-                },
-            });
+                }
+                replacements.push({
+                    source,
+                    start: imp.start,
+                    end: imp.end,
+                    value: lines.join("\n"),
+                });
+            }
             if (!replacements.length) {
                 return null;
             }
@@ -162,7 +111,10 @@ const XanixCache = () => {
                     continue;
                 try {
                     const resolved = await this.resolve(source, id);
-                    if (!resolved?.id || !resolved.id.includes("node_modules")) {
+                    if (!resolved?.id) {
+                        continue;
+                    }
+                    if (!resolved.id.includes("node_modules")) {
                         throw new Error(`Resolved module ${resolved.id} is not in node_modules`);
                     }
                     cache.resolved = resolved.id;
@@ -196,10 +148,12 @@ const XanixCache = () => {
             };
         },
         async generateBundle() {
+            const current = new Map(cached);
+            cached.clear();
             // write manifest
             const cachedManifest = await readManifest();
             const pmodules = Array.from(cachedManifest.values()).map((m) => m.module);
-            const cmodule = Array.from(cached.values()).map((m) => m.module);
+            const cmodule = Array.from(current.values()).map((m) => m.module);
             const hasChanges = pmodules.some((m) => !cmodule.includes(m)) ||
                 cmodule.some((m) => !pmodules.includes(m));
             if (hasChanges) {
@@ -207,8 +161,8 @@ const XanixCache = () => {
                     logger.info(`${pc.yellow("Optimizing dependencies")} `, "[optimize]");
                 }
                 init = true;
-                await buildCache(cached);
-                await writeManifest(cached);
+                await buildCache(current);
+                await writeManifest(current);
             }
         },
     };

package/dist/bin/bundler/cache/utils.d.ts

@@ -1,5 +1,6 @@
+import type { CachedMap } from "./types.js";
 export declare function isPackageImport(source: string): boolean;
 export declare const makeFilename: (id: string) => string;
-export declare const writeCacheManifest: (cached: Map<string, string>) => Promise<void>;
-export declare const readCacheManifest: () => Promise<Map<any, any>>;
 export declare function isNodeBuiltin(id: string): boolean;
+export declare const writeManifest: (manifest: CachedMap) => Promise<void>;
+export declare const readManifest: () => Promise<CachedMap>;

package/dist/bin/bundler/cache/utils.js

@@ -1,22 +1,19 @@
-import fs from "fs";
-import path from "path";
+import fs from "fs/promises";
 import { builtinModules } from "node:module";
+import outdirs from "../../../outdirs.js";
+const nodeBuiltins = new Set(builtinModules);
 export function isPackageImport(source) {
-    // Relative import
     if (source.startsWith("./") || source.startsWith("../")) {
         return false;
     }
-    // Absolute filesystem path
     if (source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source)) {
         return false;
     }
-    // URL / virtual module
     if (source.startsWith("node:") ||
         source.includes(":") ||
         source.startsWith("\0")) {
         return false;
     }
-    // Everything else is a bare package specifier
     return true;
 }
 export const makeFilename = (id) => {
@@ -31,26 +28,32 @@ export const makeFilename = (id) => {
         .split("?")[0];
     return id;
 };
-export const writeCacheManifest = async (cached) => {
-    const file = path.resolve("node_modules/xanix-cache/manifest.json");
-    let manifest = {};
-    for (const [key, value] of cached.entries()) {
-        manifest[key] = value;
+export function isNodeBuiltin(id) {
+    const normalized = id.startsWith("node:") ? id.slice(5) : id;
+    return nodeBuiltins.has(normalized);
+}
+const manifestFile = `${outdirs.module_cache}/manifest.json`;
+export const writeManifest = async (manifest) => {
+    const data = Array.from(manifest.values());
+    for (const item of data) {
+        delete item.exports;
+        delete item.default;
+        delete item.resolved;
+        delete item.name;
     }
-    await fs.promises.writeFile(file, JSON.stringify(manifest, null, 2));
+    await fs.writeFile(manifestFile, JSON.stringify(data, null, 2), "utf-8");
 };
-export const readCacheManifest = async () => {
-    const file = path.resolve("node_modules/xanix-cache/manifest.json");
-    if (!fs.existsSync(file)) {
+export const readManifest = async () => {
+    try {
+        const content = await fs.readFile(manifestFile, "utf-8");
+        const parsed = JSON.parse(content);
+        let data = new Map();
+        for (let p of parsed) {
+            data.set(p.module, p);
+        }
+        return data;
+    }
+    catch {
         return new Map();
     }
-    const content = await fs.promises.readFile(file, "utf-8");
-    const parsed = JSON.parse(content);
-    const map = new Map(Object.entries(parsed));
-    return map;
 };
-const nodeBuiltins = new Set(builtinModules);
-export function isNodeBuiltin(id) {
-    const normalized = id.startsWith("node:") ? id.slice(5) : id;
-    return nodeBuiltins.has(normalized);
-}

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

@@ -51,7 +51,7 @@ const buildClient = async () => {
         dir: outdirs.client,
         minify: true,
         format: "esm",
-        chunkFileNames: "chunks/[hash].js",
+        chunkFileNames: "chunks/[hash]c.js",
         assetFileNames: "assets/[name][extname]",
         entryFileNames: `runtime.js`,
     });

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+import callbackReplacer from "../../../../finder/callbackReplacer.js";
 import { frameworkDir } from "../../../../include/utils.js";
 const TransformCacheFunction = (code, imports, uid, source) => {
     let count = 0;

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

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

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

@@ -1,4 +1,4 @@
-import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+import callbackReplacer from "../../../../finder/callbackReplacer.js";
 import { frameworkDir } from "../../../../include/utils.js";
 const TransformCreateSession = (code, imports, uid, source) => {
     let count = 0;

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

@@ -0,0 +1,13 @@
+import { CachedModule } from "../Transformer.js";
+declare class TransformDevModule {
+    replacements: {
+        start: number;
+        end: number;
+        value: string;
+    }[];
+    packages: string[];
+    cached: Map<string, CachedModule>;
+    constructor(cached: Map<string, CachedModule>);
+    transform(node: any): void;
+}
+export default TransformDevModule;

package/dist/bin/bundler/client/plugins/Transformer/{transformModuleCache.js → TransformDevModule.js}

@@ -1,25 +1,13 @@
-import { builtinModules } from "node:module";
-import { isPackageImport, makeFilename } from "../../../cache/utils.js";
-const nodeBuiltins = new Set(builtinModules);
-function isNodeBuiltin(id) {
-    const normalized = id.startsWith("node:") ? id.slice(5) : id;
-    return nodeBuiltins.has(normalized);
-}
+import { isPackageImport, makeFilename, isNodeBuiltin, } from "../../../cache/utils.js";
 function makeImportName(name) {
     return `require_${name.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
 }
-function getCachePath(moduleName) {
-    const safeName = moduleName
-        .replace(/^@/, "")
-        .replace(/[\/\\]/g, "_")
-        .replace(/[^a-zA-Z0-9_$.-]/g, "_");
-    return `/cache/${safeName}.js`;
-}
-class TransformModuleCache {
+class TransformDevModule {
     constructor(cached) {
+        this.replacements = [];
         this.packages = [];
         this.replacements = [];
-        this.cacheChanged = false;
+        this.packages = [];
         this.cached = cached;
     }
     transform(node) {
@@ -101,7 +89,7 @@ class TransformModuleCache {
          * Add the package only once.
          */
         if (!this.cached.has(source)) {
-            this.cacheChanged = true;
+            //   cacheChanged = true;
             this.cached.set(source, {
                 module: source,
                 name,
@@ -117,4 +105,4 @@ class TransformModuleCache {
         });
     }
 }
-export default TransformModuleCache;
+export default TransformDevModule;

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

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

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

@@ -1,4 +1,4 @@
-import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+import callbackReplacer from "../../../../finder/callbackReplacer.js";
 import { frameworkDir } from "../../../../include/utils.js";
 const TransformServerFunction = (code, imports, uid, source) => {
     let count = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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