xanix 0.0.0 → 1.0.0

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

@@ -0,0 +1,7 @@
+import { Plugin } from "rollup";
+import { XanixClientEntry } from "../../types";
+export type XanixWatchChangeClientOptions = {
+    onChange?: (entry: string, event: "update" | "delete" | "create" | undefined) => void;
+};
+declare const XanixWatchChangeClient: (entries: XanixClientEntry[], options: XanixWatchChangeClientOptions) => Plugin;
+export default XanixWatchChangeClient;

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

@@ -0,0 +1,15 @@
+import path from "path";
+import { readManifest } from "../../include/manifest.js";
+const XanixWatchChangeClient = (entries, options) => {
+    return {
+        name: "xanix-watch-client",
+        async watchChange(id, change) {
+            const entry = path.resolve(id).replaceAll("\\", "/");
+            const manifest = await readManifest();
+            if (!manifest)
+                return;
+            options.onChange?.(entry, change?.event);
+        },
+    };
+};
+export default XanixWatchChangeClient;

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

@@ -0,0 +1,3 @@
+import { RollupCommonJSOptions } from "@rollup/plugin-commonjs";
+declare const rollupCommonjs: (opt?: RollupCommonJSOptions) => import("rollup").Plugin<any>;
+export default rollupCommonjs;

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

@@ -0,0 +1,10 @@
+import commonjs from "@rollup/plugin-commonjs";
+const rollupCommonjs = (opt) => {
+    return commonjs({
+        include: /node_modules/,
+        extensions: [".js", ".cjs"],
+        transformMixedEsModules: true,
+        ...opt,
+    });
+};
+export default rollupCommonjs;

package/dist/bin/bundler/plugins/dep-XanixWatchChange.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from "rollup";
+import { XanixClientEntry } from "../../types";
+export type XanixWatchChangeOptions = {
+    onClientEntryChange?: (entry: string, entries: XanixClientEntry[]) => Promise<void>;
+    onServerChange?: (entry: string, entries: XanixClientEntry[]) => Promise<void>;
+    onChange?: (entry: string, event: "update" | "delete" | "create" | undefined) => void;
+};
+declare const XanixWatchChange: (entries: XanixClientEntry[], options: XanixWatchChangeOptions) => Plugin;
+export default XanixWatchChange;

package/dist/bin/bundler/plugins/dep-XanixWatchChange.js

@@ -0,0 +1,27 @@
+import path from "path";
+import { createManifest, readManifest } from "../../include/manifest.js";
+import generateClientEntries from "../generateClientEntries.js";
+import { entriesEqual } from "../../include/entry.js";
+const XanixWatchChange = (entries, options) => {
+    return {
+        name: "xanix-watch-server",
+        async watchChange(id, change) {
+            const entry = path.resolve(id).replaceAll("\\", "/");
+            const manifest = await readManifest();
+            if (!manifest)
+                return;
+            const isClientEntry = Array.from(manifest.entries.values()).find((e) => e.file === entry);
+            if (!isClientEntry) {
+                const entries = await generateClientEntries();
+                const isEqual = await entriesEqual(entries);
+                if (!isEqual) {
+                    await createManifest(entries);
+                    await options.onClientEntryChange?.(entry, entries);
+                }
+                await options.onServerChange?.(entry, entries);
+            }
+            options.onChange?.(entry, change?.event);
+        },
+    };
+};
+export default XanixWatchChange;

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

@@ -0,0 +1,3 @@
+import { RollupNodeResolveOptions } from "@rollup/plugin-node-resolve";
+declare const rollupNodeResolve: (browser?: boolean, options?: RollupNodeResolveOptions) => import("rollup").Plugin<any>;
+export default rollupNodeResolve;

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

@@ -0,0 +1,10 @@
+import nodeResolve from "@rollup/plugin-node-resolve";
+const rollupNodeResolve = (browser = true, options) => {
+    return nodeResolve({
+        extensions: [".mjs", ".js", ".json", ".node", ".ts", ".tsx", ".jsx"],
+        browser: browser,
+        preferBuiltins: !browser,
+        ...options,
+    });
+};
+export default rollupNodeResolve;

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

@@ -0,0 +1,5 @@
+import type { Plugin } from "rollup";
+/**
+ * Create Rollup aliases from tsconfig.json paths.
+ */
+export declare function xanixTsconfigAlias(): Plugin;

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

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
+import alias from "@rollup/plugin-alias";
+/**
+ * Create Rollup aliases from tsconfig.json paths.
+ */
+export function xanixTsconfigAlias() {
+    const root = process.cwd();
+    const tsconfigPath = path.resolve(root, "tsconfig.json");
+    if (!fs.existsSync(tsconfigPath)) {
+        return {
+            name: "xanix-tsconfig-alias",
+        };
+    }
+    let tsconfig;
+    try {
+        const content = fs.readFileSync(tsconfigPath, "utf8");
+        tsconfig = JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`[xanix] Failed to read tsconfig.json: ${tsconfigPath}\n${String(error)}`);
+    }
+    const compilerOptions = tsconfig.compilerOptions ?? {};
+    const baseUrl = compilerOptions.baseUrl ?? ".";
+    const basePath = path.resolve(path.dirname(tsconfigPath), baseUrl);
+    const paths = compilerOptions.paths ?? {};
+    const entries = Object.entries(paths)
+        .map(([find, replacements]) => {
+        const replacement = replacements[0];
+        if (!replacement) {
+            return null;
+        }
+        const hasWildcard = find.includes("*");
+        if (hasWildcard) {
+            const findPrefix = find.replace(/\/?\*$/, "");
+            const replacementPrefix = replacement.replace(/\/?\*$/, "");
+            return {
+                find: new RegExp(`^${escapeRegExp(findPrefix)}\\/(.+)$`),
+                replacement: `${path.resolve(basePath, replacementPrefix)}/$1`,
+            };
+        }
+        return {
+            find,
+            replacement: path.resolve(basePath, replacement),
+        };
+    })
+        .filter((entry) => entry !== null);
+    return alias({
+        entries,
+    });
+}
+/**
+ * Escape a string for use inside RegExp.
+ */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

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

@@ -0,0 +1,8 @@
+import type { Plugin } from "rollup";
+export interface XanixRollupOptions {
+    target?: "client" | "server";
+    development?: boolean;
+    assetExternal?: boolean;
+    onChange?: (entry: string, event?: string) => void;
+}
+export declare function xanixDefaultPlugins(options?: XanixRollupOptions): Plugin[];

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

@@ -0,0 +1,75 @@
+import XanixTsconfigAlias from "./XanixTsconfigAlias.js";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import json from "@rollup/plugin-json";
+import esbuild from "rollup-plugin-esbuild";
+import url from "@rollup/plugin-url";
+import path from "path";
+import { XanixTransform } from "./XanixTransform/index.js";
+import xanixReactRefresh from "./XanixReactRefresh.js";
+import XanixEnvPlugin from "./XanixEnv.js";
+import xanixUseDataId from "./xanixUseDataId.js";
+export function xanixDefaultPlugins(options = {}) {
+    const target = options.target ?? "client";
+    const development = options.development ?? true;
+    const isClient = target === "client";
+    const isServer = target === "server";
+    let _plugins = [];
+    if (isServer) {
+        _plugins.push(XanixTransform({ mode: development ? "watch" : "start" }));
+        // _plugins.push(xanixServerData());
+    }
+    else {
+        if (development) {
+            _plugins.push(xanixReactRefresh());
+        }
+    }
+    return [
+        {
+            name: "watch",
+            async watchChange(id, change) {
+                const entry = path.resolve(id).replaceAll("\\", "/");
+                options.onChange?.(entry, change?.event);
+            },
+        },
+        url({
+            include: [
+                "**/*.jpg",
+                "**/*.jpeg",
+                "**/*.png",
+                "**/*.gif",
+                "**/*.webp",
+                "**/*.svg",
+                "**/*.ico",
+                "**/*.woff",
+                "**/*.woff2",
+                "**/*.ttf",
+                "**/*.eot",
+                "**/*.css",
+            ],
+            limit: 0,
+            fileName: "assets/[name]-[hash][extname]",
+            emitFiles: !(options?.assetExternal ?? false),
+        }),
+        XanixTsconfigAlias(),
+        XanixEnvPlugin({
+            mode: development ? "development" : "production",
+            isClient,
+        }),
+        nodeResolve({
+            browser: isClient,
+            preferBuiltins: isServer,
+            extensions: [".mjs", ".js", ".jsx", ".json", ".ts", ".tsx"],
+        }),
+        commonjs(),
+        json(),
+        xanixUseDataId(),
+        ..._plugins,
+        esbuild({
+            target: isClient ? "es2022" : "node20",
+            jsx: "automatic",
+            tsconfig: false,
+            minify: !development,
+        }),
+    ];
+}

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

@@ -0,0 +1,3 @@
+import { Options } from "rollup-plugin-esbuild";
+declare const rollupEsbuild: (options?: Options) => import("rollup").Plugin<any>;
+export default rollupEsbuild;

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

@@ -0,0 +1,14 @@
+import esbuild from "rollup-plugin-esbuild";
+const rollupEsbuild = (options) => {
+    return esbuild({
+        target: "es2022",
+        platform: "browser",
+        format: "esm",
+        jsx: "automatic",
+        sourceMap: false,
+        minify: false,
+        include: /\.(mjs|js|cjs|ts|tsx|jsx)$/,
+        ...options,
+    });
+};
+export default rollupEsbuild;

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

@@ -0,0 +1,6 @@
+import type { Plugin } from "rollup";
+interface XanixServerDataOptions {
+    root?: string;
+}
+export default function xanixServerData(options?: XanixServerDataOptions): Plugin;
+export {};

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

@@ -0,0 +1,224 @@
+import path from "node:path";
+import crypto from "node:crypto";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+function createLoaderId(filename, start) {
+    const relative = path.relative(process.cwd(), filename).replace(/\\/g, "/");
+    const value = `${relative}:${start}`;
+    return crypto.createHash("sha256").update(value).digest("hex").slice(0, 16);
+}
+function getArgumentNames(node) {
+    const names = [];
+    for (const property of node.properties) {
+        if (!t.isObjectProperty(property)) {
+            continue;
+        }
+        if (t.isIdentifier(property.key)) {
+            names.push(property.key.name);
+        }
+    }
+    return names;
+}
+export default function xanixServerData(options = {}) {
+    const root = options.root ?? process.cwd();
+    return {
+        name: "xanix-server-data",
+        transform(code, id) {
+            if (id.includes("node_modules") || !/\.(js|jsx|ts|tsx)$/.test(id)) {
+                return null;
+            }
+            const ast = parse(code, {
+                sourceType: "module",
+                plugins: ["typescript", "jsx"],
+            });
+            let hasUseData = false;
+            let changed = false;
+            const loaderStatements = [];
+            // --------------------------------------------------
+            // Find useData
+            // --------------------------------------------------
+            traverse(ast, {
+                ImportDeclaration(importPath) {
+                    if (importPath.node.source.value !== "xanix") {
+                        return;
+                    }
+                    for (const specifier of importPath.node.specifiers) {
+                        if (t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported) &&
+                            specifier.imported.name === "useData") {
+                            hasUseData = true;
+                        }
+                    }
+                },
+            });
+            if (!hasUseData) {
+                return null;
+            }
+            // --------------------------------------------------
+            // Transform useData()
+            // --------------------------------------------------
+            traverse(ast, {
+                CallExpression(callPath) {
+                    const node = callPath.node;
+                    if (!t.isIdentifier(node.callee) || node.callee.name !== "useData") {
+                        return;
+                    }
+                    const callback = node.arguments[0];
+                    const args = node.arguments[1];
+                    if (!callback ||
+                        !(t.isArrowFunctionExpression(callback) ||
+                            t.isFunctionExpression(callback))) {
+                        return;
+                    }
+                    if (!args || !t.isObjectExpression(args)) {
+                        return;
+                    }
+                    const loaderId = createLoaderId(id, node.start ?? 0);
+                    const argumentNames = getArgumentNames(args);
+                    // ----------------------------------------------
+                    // Clone callback body
+                    // ----------------------------------------------
+                    const callbackBody = t.cloneNode(callback.body, true);
+                    // ----------------------------------------------
+                    // Create:
+                    //
+                    // async ({ category }) => {
+                    //   ...
+                    // }
+                    // ----------------------------------------------
+                    const parameterProperties = argumentNames.map((name) => t.objectProperty(t.identifier(name), t.identifier(name), false, true));
+                    const loaderParameter = t.objectPattern(parameterProperties);
+                    let loaderFunction;
+                    if (t.isBlockStatement(callbackBody)) {
+                        loaderFunction = t.arrowFunctionExpression([loaderParameter], callbackBody, callback.async);
+                    }
+                    else {
+                        loaderFunction = t.arrowFunctionExpression([loaderParameter], callbackBody, callback.async);
+                    }
+                    // ----------------------------------------------
+                    // registerLoader(...)
+                    // ----------------------------------------------
+                    const registerLoader = t.expressionStatement(t.callExpression(t.identifier("registerLoader"), [
+                        t.stringLiteral(loaderId),
+                        loaderFunction,
+                    ]));
+                    loaderStatements.push(registerLoader);
+                    // ----------------------------------------------
+                    // Replace:
+                    //
+                    // useData(callback, args)
+                    //
+                    // with:
+                    //
+                    // useLoader(
+                    //   page.pageId,
+                    //   "id",
+                    //   args
+                    // )
+                    // ----------------------------------------------
+                    const useLoader = t.callExpression(t.identifier("useLoader"), [
+                        t.memberExpression(t.identifier("page"), t.identifier("pageId")),
+                        t.stringLiteral(loaderId),
+                        t.cloneNode(args, true),
+                    ]);
+                    callPath.replaceWith(useLoader);
+                    changed = true;
+                },
+            });
+            if (!changed) {
+                return null;
+            }
+            // --------------------------------------------------
+            // Remove useData from import
+            // --------------------------------------------------
+            traverse(ast, {
+                ImportDeclaration(importPath) {
+                    if (importPath.node.source.value !== "xanix") {
+                        return;
+                    }
+                    importPath.node.specifiers = importPath.node.specifiers.filter((specifier) => {
+                        return !(t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported) &&
+                            specifier.imported.name === "useData");
+                    });
+                    if (importPath.node.specifiers.length === 0) {
+                        importPath.remove();
+                    }
+                },
+            });
+            // --------------------------------------------------
+            // Add imports
+            // --------------------------------------------------
+            const program = ast.program;
+            let importEnd = 0;
+            while (importEnd < program.body.length &&
+                t.isImportDeclaration(program.body[importEnd])) {
+                importEnd++;
+            }
+            const usePageImport = t.importDeclaration([t.importSpecifier(t.identifier("usePage"), t.identifier("usePage"))], t.stringLiteral("xanix"));
+            const loaderImport = t.importDeclaration([
+                t.importSpecifier(t.identifier("useLoader"), t.identifier("useLoader")),
+                t.importSpecifier(t.identifier("registerLoader"), t.identifier("registerLoader")),
+            ], t.stringLiteral("xanix/runtime/loader"));
+            program.body.splice(importEnd, 0, usePageImport, loaderImport);
+            // --------------------------------------------------
+            // Insert registerLoader calls
+            // after imports
+            // --------------------------------------------------
+            program.body.splice(importEnd + 2, 0, ...loaderStatements);
+            // --------------------------------------------------
+            // Add:
+            //
+            // const page = usePage();
+            //
+            // to function containing useLoader()
+            // --------------------------------------------------
+            traverse(ast, {
+                Function(functionPath) {
+                    let hasUseLoader = false;
+                    functionPath.traverse({
+                        CallExpression(innerPath) {
+                            if (t.isIdentifier(innerPath.node.callee, {
+                                name: "useLoader",
+                            })) {
+                                hasUseLoader = true;
+                                innerPath.stop();
+                            }
+                        },
+                    });
+                    if (!hasUseLoader) {
+                        return;
+                    }
+                    if (!t.isBlockStatement(functionPath.node.body)) {
+                        return;
+                    }
+                    const alreadyHasPage = functionPath.node.body.body.some((statement) => {
+                        if (!t.isVariableDeclaration(statement)) {
+                            return false;
+                        }
+                        return statement.declarations.some((declaration) => t.isIdentifier(declaration.id, {
+                            name: "page",
+                        }));
+                    });
+                    if (alreadyHasPage) {
+                        return;
+                    }
+                    const declaration = t.variableDeclaration("const", [
+                        t.variableDeclarator(t.identifier("page"), t.callExpression(t.identifier("usePage"), [])),
+                    ]);
+                    functionPath.node.body.body.unshift(declaration);
+                },
+            });
+            const output = generate(ast, {
+                sourceMaps: true,
+                sourceFileName: id,
+            }, code);
+            return {
+                code: output.code,
+                map: output.map,
+            };
+        },
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { Plugin } from "rollup";
+export interface XanixTsconfigAliasOptions {
+    tsconfigPath?: string;
+    root?: string;
+}
+export default function xanixTsconfigAlias(options?: XanixTsconfigAliasOptions): Plugin;

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

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import alias from "@rollup/plugin-alias";
+export default function xanixTsconfigAlias(options = {}) {
+    const root = options.root ?? process.cwd();
+    const tsconfigPath = options.tsconfigPath
+        ? path.resolve(root, options.tsconfigPath)
+        : path.resolve(root, "tsconfig.json");
+    if (!fs.existsSync(tsconfigPath)) {
+        return {
+            name: "xanix-tsconfig-alias",
+        };
+    }
+    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    if (configFile.error) {
+        const message = ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
+        throw new Error(`[xanix] Failed to read tsconfig.json:\n${message}`);
+    }
+    const config = configFile.config;
+    const compilerOptions = config.compilerOptions ?? {};
+    const baseUrl = compilerOptions.baseUrl ?? ".";
+    const basePath = path.resolve(path.dirname(tsconfigPath), baseUrl);
+    const paths = compilerOptions.paths ?? {};
+    const entries = Object.entries(paths)
+        .map(([find, replacements]) => {
+        const replacement = replacements[0];
+        if (!replacement) {
+            return null;
+        }
+        if (find.includes("*")) {
+            const findPrefix = find.replace(/\/?\*$/, "");
+            const replacementPrefix = replacement.replace(/\/?\*$/, "");
+            return {
+                find: new RegExp(`^${escapeRegExp(findPrefix)}/(.+)$`),
+                replacement: `${path.resolve(basePath, replacementPrefix)}/$1`,
+            };
+        }
+        return {
+            find,
+            replacement: path.resolve(basePath, replacement),
+        };
+    })
+        .filter((entry) => entry !== null);
+    return alias({
+        entries,
+    });
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

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

@@ -0,0 +1,4 @@
+export default function xanixUseDataTransform(): {
+    name: string;
+    transform(code: string, id: string): any;
+};

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

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import generate from "@babel/generator";
+import nodePath from "node:path";
+import * as t from "@babel/types";
+export default function xanixUseDataTransform() {
+    return {
+        name: "xanix-use-data-transform",
+        transform(code, id) {
+            if (!/\.[cm]?[jt]sx?$/.test(id)) {
+                return null;
+            }
+            if (!code.includes("useData")) {
+                return null;
+            }
+            const ast = parse(code, {
+                sourceType: "module",
+                plugins: ["typescript", "jsx"],
+            });
+            let changed = false;
+            let counter = 0;
+            const registrations = [];
+            traverse(ast, {
+                CallExpression(path) {
+                    const { node } = path;
+                    // Match useData(...)
+                    if (!t.isIdentifier(node.callee, { name: "useData" })) {
+                        return;
+                    }
+                    const callback = node.arguments[0];
+                    if (!callback) {
+                        return;
+                    }
+                    // First argument must be function
+                    if (!t.isFunctionExpression(callback) &&
+                        !t.isArrowFunctionExpression(callback)) {
+                        return;
+                    }
+                    const args = node.arguments[1] ?? t.objectExpression([]);
+                    // Stable ID based on file + position
+                    const relative = nodePath
+                        .relative(process.cwd(), id)
+                        .replace(/\\/g, "/");
+                    const start = node.start ?? 0;
+                    const hash = createHash("sha256")
+                        .update(`${relative}:${start}`)
+                        .digest("hex");
+                    const xanixId = hash.slice(0, 12);
+                    // Generated hook name
+                    const hookName = `useXanixData${counter++}`;
+                    // Create:
+                    //
+                    // const useXanixData0 = useData.register(
+                    //   "id",
+                    //   callback
+                    // );
+                    const registration = t.variableDeclaration("const", [
+                        t.variableDeclarator(t.identifier(hookName), t.callExpression(t.memberExpression(t.identifier("useData"), t.identifier("register")), [t.stringLiteral(xanixId), callback])),
+                    ]);
+                    registrations.push(registration);
+                    // Replace:
+                    //
+                    // useData(callback, args)
+                    //
+                    // with:
+                    //
+                    // useXanixData0(args)
+                    path.replaceWith(t.callExpression(t.identifier(hookName), [args]));
+                    changed = true;
+                },
+            });
+            if (!changed) {
+                return null;
+            }
+            // Add registrations after imports
+            const body = ast.program.body;
+            let insertIndex = 0;
+            while (insertIndex < body.length &&
+                t.isImportDeclaration(body[insertIndex])) {
+                insertIndex++;
+            }
+            body.splice(insertIndex, 0, ...registrations);
+            const output = generate(ast, {
+                retainLines: true,
+            }, code);
+            return {
+                code: output.code,
+                map: null,
+            };
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+import { type RollupWatcher } from "rollup";
+import { XanixClientEntry } from "../types.js";
+type Option = {
+    onChange?: (entry: string, event?: string) => void;
+    onBuildEnd?: () => void;
+};
+declare const WatchClient: (entries: XanixClientEntry[], options: Option) => Promise<RollupWatcher>;
+export default WatchClient;