xanix 1.0.18 → 1.0.20

package/dist/bin/bundler/config/output.js

@@ -22,27 +22,28 @@ const client = (entries, { isDev }) => {
     }
     else {
         opt.chunkFileNames = "chunks/[hash].js";
-        opt.assetFileNames = "assets/[name]-[hash][extname]";
+        opt.assetFileNames = "assets/[name][extname]";
     }
     return opt;
 };
 const server = (opt) => {
-    return {
+    const options = {
         dir: outdirs.server,
         format: "esm",
-        sourcemap: opt.isDev ?? true,
         entryFileNames: "[name].js",
         chunkFileNames: "chunks/[name].js",
-        assetFileNames: "assets/[hash][extname]",
-        // manualChunks(id) {
-        //   const filename = path.basename(id);
-        //   return filename.split(".")[0];
-        //   return "vendor";
-        //   if (id.includes("virtual:xanix-document")) {
-        //     return "vendor";
-        //   }
-        // },
+        assetFileNames: "assets/[name][extname]",
     };
+    if (opt.isDev) {
+        options.sourcemap = true;
+        // options.preserveModules = true;
+        // options.preserveModulesRoot = process.cwd();
+    }
+    else {
+        options.chunkFileNames = "chunks/[hash].js";
+        options.assetFileNames = "assets/[name][extname]";
+    }
+    return options;
 };
 const bundlerOutput = {
     client,

package/dist/bin/bundler/externalResolver-dep.d.ts

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

package/dist/bin/bundler/externalResolver-dep.js

@@ -0,0 +1,203 @@
+import path from "path";
+import fs from "fs";
+import { rolldown } from "rolldown";
+import loadEnv from "../include/loadEnv.js";
+import { tsconfigPathsMatcher } from "../plugins/XanixTsconfigAlias.js";
+import { builtinModules } from "module";
+const nodeBuiltins = new Set(builtinModules);
+function isNodeBuiltin(id) {
+    const normalized = id.startsWith("node:") ? id.slice(5) : id;
+    return nodeBuiltins.has(normalized);
+}
+const makeFilename = (id) => {
+    let root = process.cwd().replace(/\\/g, "/").replace(/\/+/g, "/");
+    id = id
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/\/+/g, "-")
+        .replace(`${root}/`, "")
+        .replace("node_modules/", "")
+        .toLowerCase()
+        .split("?")[0];
+    return id;
+};
+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;
+}
+const writeManifest = async (cached) => {
+    const file = path.resolve("node_modules/xanix-cache/manifest.json");
+    let manifest = {};
+    for (const [key, value] of cached.entries()) {
+        manifest[key] = value;
+    }
+    await fs.promises.writeFile(file, JSON.stringify(manifest, null, 2));
+};
+const readManifest = async () => {
+    const file = path.resolve("node_modules/xanix-cache/manifest.json");
+    if (!fs.existsSync(file)) {
+        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 externalResolver = () => {
+    let initialBuild = false;
+    const cache = new Map();
+    return {
+        name: "externalResolver",
+        async buildStart() {
+            if (initialBuild) {
+                return;
+            }
+            initialBuild = true;
+            const cacheDir = path.resolve("node_modules/xanix-cache");
+            // delete cache directory if it exists
+            if (fs.existsSync(cacheDir)) {
+                fs.rmSync(cacheDir, { recursive: true, force: true });
+            }
+            if (!fs.existsSync(cacheDir)) {
+                fs.mkdirSync(cacheDir, { recursive: true });
+                fs.writeFileSync(path.join(cacheDir, "package.json"), JSON.stringify({ type: "module" }));
+            }
+        },
+        async resolveId(source, importer) {
+            if (!importer) {
+                return null;
+            }
+            if (source.startsWith("/xanix-cache")) {
+                return {
+                    id: source,
+                    external: true,
+                };
+            }
+            return null;
+            // if (importer.includes("node_modules")) {
+            //   return null;
+            // }
+            // if (source.startsWith("xanix")) {
+            //   return null;
+            // }
+            // if (!isPackageImport(source)) {
+            //   return null;
+            // }
+            // const name = makeFilename(source);
+            // cache.set(source, name);
+            // return {
+            //   id: `xanix-cache/${name}.js`,
+            //   external: true,
+            // };
+        },
+        transform(code) {
+            let changed = false;
+            const transformed = code.replace(/import\s*\{([^}]+)\}\s*from\s*(['"])([^'"]+)\2\s*;?/g, (match, imports, quote, source) => {
+                if (source.startsWith("xanix")) {
+                    return match;
+                }
+                if (!isPackageImport(source)) {
+                    return match;
+                }
+                const cleanSource = source.split("?")[0];
+                const name = makeFilename(cleanSource);
+                cache.set(cleanSource, name);
+                changed = true;
+                const localName = `_${name.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
+                const declarations = imports
+                    .split(",")
+                    .map((item) => {
+                    const [imported, local] = item
+                        .trim()
+                        .split(/\s+as\s+/)
+                        .map((x) => x.trim());
+                    return local ? `${imported}: ${local}` : imported;
+                })
+                    .join(", ");
+                return [
+                    `import ${localName} from ${quote}/xanix-cache/${name}.js${quote};`,
+                    `const { ${declarations} } = ${localName};`,
+                ].join("\n");
+            });
+            if (!changed) {
+                return null;
+            }
+            return {
+                code: transformed,
+                map: null,
+            };
+        },
+        async generateBundle() {
+            let manifest = await readManifest();
+            let changed = false;
+            const input = {};
+            for (const [source, name] of cache.entries()) {
+                input[name] = source;
+                if (!manifest.has(source)) {
+                    manifest.set(source, name);
+                    changed = true;
+                }
+            }
+            if (!changed) {
+                return;
+            }
+            const build = await rolldown({
+                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,
+                    }),
+                },
+                external(id) {
+                    if (isNodeBuiltin(id)) {
+                        return true;
+                    }
+                    if (id === "is-promise") {
+                        return true;
+                    }
+                    if (id === "virtual:xanix-document" || tsconfigPathsMatcher(id)) {
+                        return false;
+                    }
+                    return false;
+                },
+            });
+            await build.write({
+                dir: "node_modules/xanix-cache",
+                format: "es",
+                entryFileNames: "[name].js",
+            });
+            await build.close();
+            await writeManifest(manifest);
+        },
+    };
+};
+export default externalResolver;

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

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

package/dist/bin/bundler/externalResolver.js

@@ -0,0 +1,203 @@
+import path from "path";
+import fs from "fs";
+import { rolldown } from "rolldown";
+import loadEnv from "./config/loadEnv.js";
+import { tsconfigPathsMatcher } from "./plugins/XanixTsconfigAlias.js";
+import { builtinModules } from "module";
+const nodeBuiltins = new Set(builtinModules);
+function isNodeBuiltin(id) {
+    const normalized = id.startsWith("node:") ? id.slice(5) : id;
+    return nodeBuiltins.has(normalized);
+}
+const makeFilename = (id) => {
+    let root = process.cwd().replace(/\\/g, "/").replace(/\/+/g, "/");
+    id = id
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/\/+/g, "-")
+        .replace(`${root}/`, "")
+        .replace("node_modules/", "")
+        .toLowerCase()
+        .split("?")[0];
+    return id;
+};
+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;
+}
+const writeManifest = async (cached) => {
+    const file = path.resolve("node_modules/xanix-cache/manifest.json");
+    let manifest = {};
+    for (const [key, value] of cached.entries()) {
+        manifest[key] = value;
+    }
+    await fs.promises.writeFile(file, JSON.stringify(manifest, null, 2));
+};
+const readManifest = async () => {
+    const file = path.resolve("node_modules/xanix-cache/manifest.json");
+    if (!fs.existsSync(file)) {
+        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 externalResolver = () => {
+    let initialBuild = false;
+    const cache = new Map();
+    return {
+        name: "externalResolver",
+        async buildStart() {
+            if (initialBuild) {
+                return;
+            }
+            initialBuild = true;
+            const cacheDir = path.resolve("node_modules/xanix-cache");
+            // delete cache directory if it exists
+            if (fs.existsSync(cacheDir)) {
+                fs.rmSync(cacheDir, { recursive: true, force: true });
+            }
+            if (!fs.existsSync(cacheDir)) {
+                fs.mkdirSync(cacheDir, { recursive: true });
+                fs.writeFileSync(path.join(cacheDir, "package.json"), JSON.stringify({ type: "module" }));
+            }
+        },
+        async resolveId(source, importer) {
+            if (!importer) {
+                return null;
+            }
+            if (source.startsWith("/xanix-cache")) {
+                return {
+                    id: source,
+                    external: true,
+                };
+            }
+            return null;
+            // if (importer.includes("node_modules")) {
+            //   return null;
+            // }
+            // if (source.startsWith("xanix")) {
+            //   return null;
+            // }
+            // if (!isPackageImport(source)) {
+            //   return null;
+            // }
+            // const name = makeFilename(source);
+            // cache.set(source, name);
+            // return {
+            //   id: `xanix-cache/${name}.js`,
+            //   external: true,
+            // };
+        },
+        transform(code) {
+            let changed = false;
+            const transformed = code.replace(/import\s*\{([^}]+)\}\s*from\s*(['"])([^'"]+)\2\s*;?/g, (match, imports, quote, source) => {
+                if (source.startsWith("xanix")) {
+                    return match;
+                }
+                if (!isPackageImport(source)) {
+                    return match;
+                }
+                const cleanSource = source.split("?")[0];
+                const name = makeFilename(cleanSource);
+                cache.set(cleanSource, name);
+                changed = true;
+                const localName = `_${name.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
+                const declarations = imports
+                    .split(",")
+                    .map((item) => {
+                    const [imported, local] = item
+                        .trim()
+                        .split(/\s+as\s+/)
+                        .map((x) => x.trim());
+                    return local ? `${imported}: ${local}` : imported;
+                })
+                    .join(", ");
+                return [
+                    `import ${localName} from ${quote}/xanix-cache/${name}.js${quote};`,
+                    `const { ${declarations} } = ${localName};`,
+                ].join("\n");
+            });
+            if (!changed) {
+                return null;
+            }
+            return {
+                code: transformed,
+                map: null,
+            };
+        },
+        async generateBundle() {
+            let manifest = await readManifest();
+            let changed = false;
+            const input = {};
+            for (const [source, name] of cache.entries()) {
+                input[name] = source;
+                if (!manifest.has(source)) {
+                    manifest.set(source, name);
+                    changed = true;
+                }
+            }
+            if (!changed) {
+                return;
+            }
+            const build = await rolldown({
+                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,
+                    }),
+                },
+                external(id) {
+                    if (isNodeBuiltin(id)) {
+                        return true;
+                    }
+                    if (id === "is-promise") {
+                        return true;
+                    }
+                    if (id === "virtual:xanix-document" || tsconfigPathsMatcher(id)) {
+                        return false;
+                    }
+                    return false;
+                },
+            });
+            await build.write({
+                dir: "node_modules/xanix-cache",
+                format: "es",
+                entryFileNames: "[name].js",
+            });
+            await build.close();
+            await writeManifest(manifest);
+        },
+    };
+};
+export default externalResolver;

package/dist/bin/bundler/plugins/TransformServer/TransformExpress.d.ts

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

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

@@ -0,0 +1,26 @@
+class TransformExpress {
+    constructor() {
+        this.replacements = [];
+    }
+    transform(node) {
+        if (node.type === "ImportDeclaration" && node.source.value === "express") {
+            this.replacements.push({
+                start: node.source.start + 1,
+                end: node.source.end - 1,
+                value: "xanix/express",
+            });
+        }
+        // check require express
+        if (node.type === "CallExpression" &&
+            node.callee.name === "require" &&
+            node.arguments.length === 1 &&
+            node.arguments[0].value === "express") {
+            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/plugins/TransformServer/TransformPage.d.ts

@@ -0,0 +1,25 @@
+type Name = string;
+type Entry = {
+    name: string;
+    id: string;
+    source: string;
+    resolved: string;
+};
+declare class TransformPage {
+    _replacements: {
+        start: number;
+        end: number;
+        value: string;
+    }[];
+    imports: Map<Name, string>;
+    entries: Entry[];
+    private identifiers;
+    get replacements(): {
+        start: number;
+        end: number;
+        value: string;
+    }[];
+    uid(source: string): string;
+    transform(node: any): void;
+}
+export default TransformPage;

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

@@ -0,0 +1,79 @@
+import crypto from "node:crypto";
+class TransformPage {
+    constructor() {
+        this._replacements = [];
+        this.imports = new Map();
+        this.entries = [];
+        this.identifiers = [];
+    }
+    get replacements() {
+        for (const identifier of this.identifiers) {
+            const source = this.imports.get(identifier.name);
+            if (source) {
+                const id = this.uid(source);
+                this.entries.push({
+                    name: identifier.name,
+                    id,
+                    source,
+                    resolved: "",
+                });
+                this._replacements.push({
+                    start: identifier.placement,
+                    end: identifier.placement,
+                    value: ` __xpage={{ id: "${id}", name: "${identifier.name}" }} `,
+                });
+            }
+        }
+        return this._replacements;
+    }
+    uid(source) {
+        return crypto
+            .createHash("sha256")
+            .update(source)
+            .digest("hex")
+            .slice(0, 12);
+    }
+    transform(node) {
+        /*
+            res.send(<Home />) to
+            res.send(__xpage({
+                id: uid,
+                component: Home,
+                props: {},
+                request: req,
+                response: res,
+            }))
+        */
+        if (node.type === "CallExpression" &&
+            node.callee.property?.name === "send" &&
+            node.arguments.length === 1 &&
+            node.arguments[0].type === "JSXElement") {
+            const element = node.arguments[0].openingElement;
+            const ComponentName = element.name.name;
+            const attrs = element.attributes;
+            let end = attrs.length > 0 ? attrs[attrs.length - 1].end : element.name.end;
+            this.identifiers.push({
+                placement: end,
+                name: ComponentName,
+            });
+        }
+        // find static imports and add them to this.imports array
+        if (node.type === "ImportDeclaration" &&
+            node.specifiers.length > 0 &&
+            node.specifiers[0].type === "ImportDefaultSpecifier") {
+            const source = node.source.value;
+            const specifier = node.specifiers[0].local.name;
+            this.imports.set(specifier, source);
+        }
+        // find rfom require
+        if (node.type === "VariableDeclaration" &&
+            node.declarations.length === 1 &&
+            node.declarations[0].init?.type === "CallExpression" &&
+            node.declarations[0].init.callee.name === "require") {
+            const source = node.declarations[0].init.arguments[0].value;
+            const specifier = node.declarations[0].id.name;
+            this.imports.set(specifier, source);
+        }
+    }
+}
+export default TransformPage;

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

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