xanix 0.0.0 → 1.0.0

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

@@ -0,0 +1,126 @@
+import path from "node:path";
+import fs from "node:fs";
+import { parse } from "@babel/parser";
+import traverse from "@babel/traverse";
+import generate from "@babel/generator";
+import * as t from "@babel/types";
+import { createRequire } from "node:module";
+import { getClientRuntimeFile } from "../../include/utils.js";
+const require = createRequire(import.meta.url);
+const root = process.cwd();
+export default function xanixReactRefresh() {
+    return {
+        name: "xanix-react-refresh",
+        load(id) {
+            if (path.resolve(id) !== getClientRuntimeFile()) {
+                return null;
+            }
+            const code = fs.readFileSync(id, "utf8");
+            const refreshCode = `
+import * as RefreshRuntime from "react-refresh/runtime";
+
+${code}
+
+if (typeof window !== "undefined") {
+  RefreshRuntime.injectIntoGlobalHook(window);
+
+  window.$RefreshReg$ = RefreshRuntime.register;
+  window.$RefreshSig$ = () => (type) => type;
+
+  const ws = new WebSocket("ws://localhost:8080");
+
+  ws.onmessage = async (event) => {
+    const files = JSON.parse(event.data);
+
+    for (const file of files) {
+      if (!file.endsWith(".js")) {
+        continue;
+      }
+
+      const url =
+        getImportUrl(file.replace(/\\.js$/, "")) +
+        "?t=" +
+        Date.now();
+
+      await import(url);
+    }
+
+    RefreshRuntime.performReactRefresh();
+    ws.send("reload")
+  };
+}
+`;
+            return {
+                code: refreshCode,
+                map: null,
+            };
+        },
+        transform(code, id) {
+            if (path.resolve(id) === getClientRuntimeFile()) {
+                return null;
+            }
+            if (id.includes("node_modules") || id.includes("xanix\\dist")) {
+                return null;
+            }
+            if (!/\.(tsx?|jsx?)$/.test(id)) {
+                return null;
+            }
+            const ast = parse(code, {
+                sourceType: "module",
+                plugins: ["typescript", "jsx"],
+            });
+            const registrations = [];
+            traverse(ast, {
+                FunctionDeclaration(path) {
+                    const node = path.node;
+                    if (!node.id) {
+                        return;
+                    }
+                    const name = node.id.name;
+                    if (!isReactComponent(name)) {
+                        return;
+                    }
+                    registrations.push(createRegistration(name, id));
+                },
+                VariableDeclarator(path) {
+                    const node = path.node;
+                    if (!t.isIdentifier(node.id)) {
+                        return;
+                    }
+                    const name = node.id.name;
+                    if (!isReactComponent(name)) {
+                        return;
+                    }
+                    if (!t.isArrowFunctionExpression(node.init) &&
+                        !t.isFunctionExpression(node.init)) {
+                        return;
+                    }
+                    registrations.push(createRegistration(name, id));
+                },
+            });
+            if (registrations.length === 0) {
+                return null;
+            }
+            ast.program.body.push(...registrations);
+            const result = generate(ast, {
+                sourceMaps: true,
+                sourceFileName: id,
+            }, code);
+            return {
+                code: result.code,
+                map: result.map,
+            };
+        },
+    };
+}
+function isReactComponent(name) {
+    return /^[A-Z]/.test(name);
+}
+function createRegistration(name, filename) {
+    const relative = path.relative(root, filename).replaceAll("\\", "/");
+    const componentId = `${relative}:${name}`;
+    return t.expressionStatement(t.callExpression(t.identifier("$RefreshReg$"), [
+        t.identifier(name),
+        t.stringLiteral(componentId),
+    ]));
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { Plugin } from "rollup";
+export type XanixPluginOptions = {
+    mode: "watch" | "start";
+};
+export declare function XanixTransform(option: XanixPluginOptions): Plugin;

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

@@ -0,0 +1,19 @@
+import { transformer } from "./transformer.js";
+export function XanixTransform(option) {
+    return {
+        name: "xanix-transform",
+        async transform(code, id) {
+            if (id.includes("node_modules") || !/\.(tsx?|jsx?)$/.test(id)) {
+                return null;
+            }
+            const result = transformer(code, id, option.mode);
+            if (!result) {
+                return null;
+            }
+            return {
+                code: result.code,
+                map: result.map,
+            };
+        },
+    };
+}

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

@@ -0,0 +1,16 @@
+import * as t from "@babel/types";
+export interface XanixTransformResult {
+    code: string;
+    map: any;
+}
+export declare function resolveFile(file: string): string;
+export declare function resolveComponentFile(importer: string, importPath: string): string;
+export declare function createPageId(file: string): string;
+export declare function getJSXComponentName(node: t.JSXElement): string | null;
+export declare function findComponentImport(ast: t.File, componentName: string): {
+    file: string;
+    export: string;
+    declaration: t.ImportDeclaration;
+    specifier: t.ImportSpecifier | t.ImportDefaultSpecifier;
+} | null;
+export declare function transformer(code: string, id: string, mode: "watch" | "start"): XanixTransformResult | null;