xanix 1.0.17 → 1.0.19

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

@@ -0,0 +1,56 @@
+import fs from "fs";
+import path from "path";
+import { builtinModules } from "node:module";
+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) => {
+    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;
+};
+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;
+    }
+    await fs.promises.writeFile(file, JSON.stringify(manifest, null, 2));
+};
+export const readCacheManifest = 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 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.d.ts

@@ -0,0 +1,2 @@
+declare const buildClient: () => Promise<import("../../types.js").XanixClientEntry[]>;
+export default buildClient;

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

@@ -0,0 +1,61 @@
+import { rolldown } from "rolldown";
+import { frameworkDir } from "../../include/utils.js";
+import outdirs from "../../../outdirs.js";
+import XanixTransformer from "./plugins/Transformer.js";
+import XanixPages from "./plugins/XanixPages.js";
+import xanixAssets from "../../plugins/XanixAssets.js";
+import xanixDocument from "../../plugins/XanixDocument.js";
+import xanixTsconfigAlias from "../../plugins/XanixTsconfigAlias.js";
+import loadEnv from "../../include/loadEnv.js";
+import { getManifest } from "../../include/manifest.js";
+import path from "node:path";
+const buildClient = async () => {
+    const entries = await getManifest();
+    const build = await rolldown({
+        input: path.join(frameworkDir, "dist/client-runtime.js"),
+        treeshake: true,
+        tsconfig: true,
+        checks: {
+            moduleLevelDirective: false,
+        },
+        resolve: {
+            extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
+            conditionNames: ["browser", "import", "module", "default"],
+        },
+        transform: {
+            target: "es2022",
+            jsx: {
+                runtime: "automatic",
+            },
+            define: await loadEnv({
+                mode: "production",
+                isClient: true,
+            }),
+        },
+        onwarn(warning, warn) {
+            if (warning.code === "MODULE_LEVEL_DIRECTIVE" &&
+                warning.message.includes('"use client"')) {
+                return;
+            }
+            warn(warning);
+        },
+        plugins: [
+            xanixAssets(),
+            xanixTsconfigAlias(),
+            XanixPages(),
+            xanixDocument(),
+            XanixTransformer(),
+        ],
+    });
+    await build.write({
+        dir: outdirs.client,
+        minify: true,
+        format: "esm",
+        chunkFileNames: "chunks/[hash].js",
+        assetFileNames: "assets/[name][extname]",
+        entryFileNames: `runtime.js`,
+    });
+    await build.close();
+    return entries;
+};
+export default buildClient;

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

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

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

@@ -0,0 +1,39 @@
+class TransformCache {
+    constructor(code, importer, uid) {
+        this.replacements = [];
+        this.cacheImported = false;
+        this.count = 0;
+        this.code = code;
+        this.importer = importer;
+        this.uid = uid;
+    }
+    transform(node) {
+        // check server imported
+        if (node.type === "ImportDeclaration" &&
+            node.source.value === "xanix" &&
+            node.specifiers.some((s) => s.type === "ImportSpecifier" && s.imported.name === "cache")) {
+            this.cacheImported = true;
+        }
+        if (node.type === "CallExpression" &&
+            node.callee.type === "Identifier" &&
+            node.callee.name === "cache" &&
+            (node.arguments.length === 1 || node.arguments.length === 2)) {
+            const id = this.uid + this.count++;
+            if (node.arguments.length === 1) {
+                this.replacements.push({
+                    start: node.arguments[0].end,
+                    end: node.arguments[0].end,
+                    value: `, undefined, "${id}"`,
+                });
+            }
+            else {
+                this.replacements.push({
+                    start: node.arguments[1].end,
+                    end: node.arguments[1].end,
+                    value: `, "${id}"`,
+                });
+            }
+        }
+    }
+}
+export default TransformCache;

package/dist/bin/bundler/client/plugins/Transformer/TransformCacheFunction.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.js

@@ -0,0 +1,32 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+import { frameworkDir } from "../../../../include/utils.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(frameworkDir)) {
+        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/TransformCreateSession.d.ts

@@ -0,0 +1,3 @@
+import { ImportInfo } from "../../../../modifier/importFinder.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

@@ -0,0 +1,29 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+import { frameworkDir } from "../../../../include/utils.js";
+const TransformCreateSession = (code, imports, uid, source) => {
+    let count = 0;
+    const replacer = (code, cb) => {
+        const replacedCode = callbackReplacer(code, cb, (args) => {
+            const id = uid + count++;
+            const _id = args[1] || `"${id}"`;
+            return `${cb}(undefined, ${_id});`;
+        });
+        code = replacedCode;
+        return code;
+    };
+    if (source.startsWith(frameworkDir)) {
+        code = replacer(code, `createSession`);
+    }
+    for (let _import of imports) {
+        if (_import.namespace) {
+            code = replacer(code, `${_import.namespace}.createSession`);
+        }
+        for (let sp of _import.specifiers) {
+            if (sp.imported === "createSession") {
+                code = replacer(code, sp.local);
+            }
+        }
+    }
+    return code;
+};
+export default TransformCreateSession;

package/dist/bin/bundler/client/plugins/Transformer/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/client/plugins/Transformer/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/client/plugins/Transformer/TransformPage.d.ts

@@ -0,0 +1,29 @@
+import { TransformPluginContext } from "rolldown";
+type Name = string;
+export 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: Map<string, Entry>;
+    private identifiers;
+    private context;
+    private importer;
+    constructor(context: TransformPluginContext, importer: string, entries: Map<string, Entry>);
+    replacements(): Promise<{
+        start: number;
+        end: number;
+        value: string;
+    }[]>;
+    uid(source: string): string;
+    transform(node: any): void;
+}
+export default TransformPage;

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

@@ -0,0 +1,77 @@
+import crypto from "node:crypto";
+class TransformPage {
+    constructor(context, importer, entries) {
+        this._replacements = [];
+        this.imports = new Map();
+        this.entries = new Map();
+        this.identifiers = [];
+        this.context = context;
+        this.importer = importer;
+        this.entries = entries;
+    }
+    async replacements() {
+        for (const identifier of this.identifiers) {
+            const source = this.imports.get(identifier.name);
+            if (source) {
+                const resolved = await this.context.resolve(source, this.importer, {
+                    skipSelf: true,
+                });
+                if (resolved) {
+                    const id = this.uid(resolved.id);
+                    this.entries.set(id, {
+                        name: identifier.name,
+                        id,
+                        source,
+                        resolved: resolved?.id,
+                    });
+                    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) {
+        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/client/plugins/Transformer/TransformReactContext.d.ts

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

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

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

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

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

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

@@ -0,0 +1,42 @@
+class TransformServerAction {
+    constructor(code, importer, uid) {
+        this.replacements = [];
+        this.serverImported = false;
+        this.count = 0;
+        this.code = code;
+        this.importer = importer;
+        this.uid = uid;
+    }
+    transform(node) {
+        // check server imported
+        if (node.type === "ImportDeclaration" &&
+            node.source.value === "xanix" &&
+            node.specifiers.some((s) => s.type === "ImportSpecifier" && s.imported.name === "server")) {
+            this.serverImported = true;
+        }
+        if (node.type === "CallExpression" &&
+            node.callee.type === "Identifier" &&
+            node.callee.name === "server" &&
+            (node.arguments.length === 1 || node.arguments.length === 2) &&
+            (node.arguments[0].type === "ArrowFunctionExpression" ||
+                node.arguments[0].type === "FunctionExpression")) {
+            const id = this.uid + this.count++;
+            if (node.arguments.length === 2) {
+                const optionNode = node.arguments[1];
+                const optionString = this.code.slice(optionNode.start, optionNode.end);
+                this.replacements.push({
+                    start: node.start,
+                    end: node.end,
+                    value: `server(undefined, ${optionString}, "${id}")`,
+                });
+                return;
+            }
+            this.replacements.push({
+                start: node.start,
+                end: node.end,
+                value: `server(undefined, undefined, "${id}")`,
+            });
+        }
+    }
+}
+export default TransformServerAction;

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

@@ -0,0 +1,3 @@
+import { ImportInfo } from "../../../../modifier/importFinder.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

@@ -0,0 +1,32 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+import { frameworkDir } from "../../../../include/utils.js";
+const TransformServerFunction = (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(frameworkDir)) {
+        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 TransformServerFunction;

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

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

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

@@ -0,0 +1,31 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+import { frameworkDir } from "../../../../include/utils.js";
+const TransformUseServer = (code, imports, source) => {
+    let codes = [];
+    const replacer = (code, cb) => {
+        return callbackReplacer(code, cb, (args) => {
+            const fn = args[0];
+            const argString = args[1] ?? "undefined";
+            const options = args[2] || "undefined";
+            const varname = `_xserver_${Math.random().toString(36).substring(2, 7)}`;
+            const server_code = `const ${varname} = ${cb}.server(${fn}, ${options});`;
+            codes.push(server_code);
+            return `${cb}(${varname}, ${argString})`;
+        });
+    };
+    if (source.startsWith(frameworkDir)) {
+        code = replacer(code, `useServer`);
+    }
+    for (let _import of imports) {
+        if (_import.namespace) {
+            code = replacer(code, `${_import.namespace}.useServer`);
+        }
+        for (let sp of _import.specifiers) {
+            if (sp.imported === "useServer") {
+                code = replacer(code, sp.local);
+            }
+        }
+    }
+    return codes.join("\n") + "\n" + code;
+};
+export default TransformUseServer;

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

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