xanix 1.0.20 → 1.0.21

package/dist/bin/bundler/server/plugins/replacer/serverFunctionReplacer.d.ts

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

package/dist/bin/bundler/server/plugins/replacer/serverFunctionReplacer.js

@@ -1,5 +1,6 @@
 import callbackReplacer from "../../../../modifier/callbackReplacer.js";
-const serverFunctionReplacer = (code, imports, uid) => {
+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) => {
@@ -13,6 +14,9 @@ const serverFunctionReplacer = (code, imports, uid) => {
         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`);

package/dist/bin/bundler/server/plugins/replacer/serverReplacer.d.ts

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

package/dist/bin/bundler/server/plugins/replacer/serverReplacer.js

@@ -0,0 +1,26 @@
+import callbackReplacer from "../../../../modifier/callbackReplacer.js";
+const serverReplacer = (code, imports, uid) => {
+    let count = 0;
+    const replaceServer = (code, cb) => {
+        const replacedCode = callbackReplacer(code, cb, (args) => {
+            const id = uid + count++;
+            const fn = args[0];
+            const options = args[1] || "undefined";
+            return `${cb}(${fn}, ${options}, "${id}");`;
+        });
+        code = replacedCode;
+        return code;
+    };
+    for (let xanixImport of imports) {
+        if (xanixImport.namespace) {
+            code = replaceServer(code, `${xanixImport.namespace}.server`);
+        }
+        for (let sp of xanixImport.specifiers) {
+            if (sp.imported === "server") {
+                code = replaceServer(code, sp.local);
+            }
+        }
+    }
+    return code;
+};
+export default serverReplacer;

package/dist/bin/bundler/server/plugins/replacer/useServerReplacer.d.ts

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

package/dist/bin/bundler/server/plugins/replacer/useServerReplacer.js

@@ -1,8 +1,7 @@
+import { framworkDir } from "../../../../include/path.js";
 import callbackReplacer from "../../../../modifier/callbackReplacer.js";
-const useServerReplacer = (code, imports) => {
-    if (!imports.length)
-        return code;
-    const importName = `__xanix_server_${Math.random().toString(36).substring(2, 3)}`;
+const useServerReplacer = (code, imports, source) => {
+    const importName = `__xanix_server_${Math.random().toString(36).substring(2, 4)}`;
     let codes = [`import { server as ${importName} } from "xanix"`];
     imports.push({
         specifiers: [
@@ -17,12 +16,17 @@ const useServerReplacer = (code, imports) => {
             const fn = args[0];
             const argString = args[1] ?? "undefined";
             const options = args[2] || "undefined";
-            const varname = `_use_server_${Math.random().toString(36).substring(2, 9)}`;
+            const varname = `_use_server_${Math.random().toString(36).substring(2, 6)}`;
             const server_code = `const ${varname} = ${importName}(${fn}, ${options});`;
             codes.push(server_code);
             return `${cb}(${varname}, ${argString})`;
         });
     };
+    if (source.startsWith(framworkDir)) {
+        code = replacer(code, `useServer`);
+    }
+    if (!imports.length)
+        return code;
     for (let _import of imports) {
         if (_import.namespace) {
             code = replacer(code, `${_import.namespace}.useServer`);

package/dist/bin/cli/dev.js

@@ -10,69 +10,58 @@ import outdirs from "../../outdirs.js";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { normalizePath } from "../include/utils.js";
-const root = normalizePath(process.cwd());
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageJson = JSON.parse(await readFile(path.join(__dirname, "../../../package.json"), "utf8"));
 const serverInfo = {};
 let child;
 let firstStart = false;
-async function stopCurrentServer() {
-    if (!child || child.exitCode !== null || child.signalCode !== null) {
-        child = undefined;
-        return;
-    }
-    const previous = child;
-    await new Promise((resolve) => {
-        previous.once("exit", () => resolve());
-        previous.kill();
+const root = normalizePath(process.cwd());
+const curl = () => {
+    return new Promise((resolve, reject) => {
+        const child = spawn("curl", [serverInfo.url], {
+            stdio: "pipe",
+        });
+        child.on("error", reject);
+        child.on("close", () => resolve());
     });
-    if (child === previous) {
-        child = undefined;
-    }
-}
-async function startServer() {
-    await stopCurrentServer();
-    const filePath = path.join(outdirs.server, "index.js");
-    await new Promise((resolve, reject) => {
-        const current = spawn(process.execPath, [filePath], {
+};
+function runServer() {
+    return new Promise((resolve, reject) => {
+        child?.kill();
+        const filePath = path.join(outdirs.server, "index.js");
+        child = spawn(process.execPath, [filePath], {
             stdio: ["inherit", "inherit", "inherit", "ipc"],
         });
-        child = current;
-        const cleanup = () => {
-            current.off("message", onMessage);
-            current.off("error", onError);
-            current.off("exit", onExit);
-        };
-        const onMessage = (message) => {
-            if (message?.type !== "xanix:ready")
-                return;
-            serverInfo.port = message.port;
-            serverInfo.url = message.url;
-            if (!firstStart) {
-                firstStart = true;
-                console.log("");
-                console.log(`  ${pc.blue("➜ Listening on:")} ${pc.yellow(serverInfo.url)}`);
-                console.log("");
-            }
-            cleanup();
-            resolve();
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const onExit = (code, signal) => {
-            cleanup();
-            if (child === current) {
-                child = undefined;
+        child.on("message", async (message) => {
+            if (message.type === "xanix:ready") {
+                serverInfo.port = message.port;
+                serverInfo.url = message.url;
+                if (!firstStart) {
+                    firstStart = true;
+                    console.log("");
+                    console.log(`  ${pc.blue("➜ Listening on:")} ${pc.yellow(serverInfo.url)}`);
+                    console.log("");
+                }
+                resolve();
             }
-            reject(new Error(`Xanix server exited before ready (code: ${code}, signal: ${signal})`));
-        };
-        current.on("message", onMessage);
-        current.once("error", onError);
-        current.once("exit", onExit);
+        });
+        child.on("error", reject);
     });
 }
+let started = false;
+let timer;
+async function startServer() {
+    if (!started) {
+        await runServer();
+        started = true;
+        return;
+    }
+    clearTimeout(timer);
+    timer = setTimeout(async () => {
+        await runServer();
+        await curl();
+    }, 1000);
+}
 const dev = async (rootEntry) => {
     // await stop();
     fs.rmSync(outdirs.root, {
@@ -99,31 +88,48 @@ const dev = async (rootEntry) => {
         ws.on("close", () => {
             sockets.delete(ws);
         });
-        ws.on("message", (message) => {
-            if (message.toString() === "reload") {
-                startServer();
-            }
-        });
     });
-    console.log("");
-    console.log(pc.green(pc.bold(`Xanix`) + ` v${packageJson.version}`));
-    let clientWatcher = null;
+    let _clientWatcher = null;
     let clientStarted = false;
     let buildDuration = 0;
-    const startClientWatcher = async () => {
-        clientWatcher?.close();
-        clientWatcher = await watchClient({
+    let serverWatchReady = false;
+    const waitUntilReady = () => {
+        return new Promise((resolve) => {
+            if (serverWatchReady) {
+                resolve();
+                return;
+            }
+            const timer = setInterval(() => {
+                if (serverWatchReady) {
+                    clearInterval(timer);
+                    resolve();
+                }
+            }, 10);
+        });
+    };
+    const clientWatcher = async () => {
+        const isClientAlreadyReady = !!_clientWatcher;
+        _clientWatcher?.close();
+        _clientWatcher = await watchClient({
             onStart: async () => {
                 clientStarted = true;
             },
             onReady: async (duration) => {
+                if (!isClientAlreadyReady) {
+                    // spinner.stop(
+                    //   `${pc.green("✓")} Client compiled in ${pc.dim(buildDuration + duration + "ms")}`,
+                    // );
+                }
                 await startServer();
                 buildDuration = 0;
                 clientStarted = false;
+                serverWatchReady = false;
             },
             onChange: async (files, duration, entries) => {
+                await waitUntilReady();
                 buildDuration += duration;
                 clientStarted = false;
+                serverWatchReady = false;
                 const _files = [];
                 for (let file of files) {
                     const entry = entries.find((entry) => entry.resolved === file);
@@ -140,38 +146,46 @@ const dev = async (rootEntry) => {
                 logger.info(`${pc.yellow(files.join(", "))} ${pc.green(buildDuration + "ms")}`, "[update]");
                 broadcast(JSON.stringify(_files));
                 buildDuration = 0;
+                startServer();
             },
         });
     };
+    console.log("");
+    console.log(pc.green(pc.bold(`Xanix`) + ` v${packageJson.version}`));
+    // console.log("");
+    // spinner.start("Compiling Server...");
     const watch = await watchServer({
         rootEntry,
         onChangeManifest: async () => {
-            await startClientWatcher();
+            // Handle manifest change
+            await clientWatcher();
         },
         onReady: async (duration) => {
             buildDuration += duration;
-            await startClientWatcher();
+            serverWatchReady = true;
+            await clientWatcher();
         },
         onChange: async (files, duration) => {
             buildDuration += duration;
             if (!clientStarted) {
                 files = files.map((file) => file.replace(root + "/", ""));
-                logger.info(`${pc.yellow(files.join(", "))} ${pc.green(buildDuration + "ms")}`, "[update-server]");
+                logger.info(`${pc.yellow(files.join(", "))} ${pc.green(buildDuration + "ms")}`, "[update]");
                 buildDuration = 0;
-                await startServer();
+                startServer();
             }
+            serverWatchReady = true;
         },
     });
     process.on("SIGINT", () => {
-        clientWatcher?.close();
-        watch?.close();
         child?.kill();
+        _clientWatcher?.close();
+        watch?.close();
         process.exit(0);
     });
     process.on("SIGTERM", () => {
-        clientWatcher?.close();
-        watch?.close();
         child?.kill();
+        _clientWatcher?.close();
+        watch?.close();
         process.exit(0);
     });
 };

package/dist/bin/cli/start/index.d.ts

@@ -1,2 +1,5 @@
-declare const start: () => Promise<void>;
+declare const start: (args: {
+    external?: boolean;
+    restart?: boolean;
+}) => Promise<void>;
 export default start;

package/dist/bin/cli/start/index.js

@@ -1,27 +1,78 @@
 import { spawn } from "child_process";
 import pc from "picocolors";
+import { mkdir, open, writeFile } from "fs/promises";
 import path from "path";
 import outdirs from "../../../outdirs.js";
 import { getFrameworkPackageJson } from "../../include/utils.js";
-const start = async () => {
+import { processFiles, getProcess, processProjectDir, } from "../../include/process.js";
+import startExternal from "./external.js";
+const start = async (args) => {
+    const isExternal = args.external ?? false;
     const packageJson = await getFrameworkPackageJson();
-    console.log("");
-    console.log(pc.cyan(pc.bold(`Xanix ${packageJson.version}`)));
-    console.log("");
+    if (!args.restart) {
+        console.log("");
+        console.log(pc.cyan(pc.bold(`Xanix ${packageJson.version}`)));
+        console.log("");
+    }
+    if (isExternal) {
+        startExternal();
+        return;
+    }
+    await mkdir(processProjectDir, {
+        recursive: true,
+    });
     const filePath = path.join(outdirs.server, "index.js");
+    const files = processFiles;
+    const processFile = files.process;
+    const stdoutFile = files.logs.stdout;
+    const stderrFile = files.logs.stderr;
+    const oldProcess = await getProcess();
+    if (oldProcess) {
+        const oldPid = Number(oldProcess?.pid);
+        console.log(pc.yellow(`Xanix server is already running (${oldPid})`));
+        return;
+    }
+    // Create/open log files.
+    const stdout = await open(stdoutFile, "a");
+    const stderr = await open(stderrFile, "a");
     const child = spawn(process.execPath, [filePath], {
-        stdio: ["inherit", "inherit", "inherit", "ipc"],
+        detached: true,
+        stdio: ["ignore", stdout.fd, stderr.fd, "ipc"],
+        env: {
+            ...process.env,
+            NODE_ENV: "production",
+        },
     });
+    // Keep file handles open for the child process to use.
+    if (!child.pid) {
+        console.error(pc.red("Failed to start Xanix server."));
+        return;
+    }
+    // clear pre logs
+    await writeFile(processFile, JSON.stringify({
+        pid: child.pid,
+        cwd: process.cwd(),
+        script: filePath,
+        startedAt: Date.now(),
+    }, null, 2));
     child.on("message", (message) => {
         if (message.type === "xanix:ready") {
-            console.log(`  ${pc.blue("➜ Local:")} ${pc.yellow(message.url ?? "")}`);
-            console.log("");
-            console.log(pc.gray("Press Ctrl+C to stop"));
-            console.log("");
+            if (!args.restart) {
+                console.log(`  ${pc.gray("➜ Local:")} ${pc.yellow(message.url ?? "")}`);
+                console.log(`  ${pc.gray("➜ PID:")} ${child.pid}`);
+                console.log("");
+                console.log(pc.gray(`Run ${pc.cyan("xanix stop")} to stop the server.`));
+                console.log("");
+            }
+            child.disconnect();
+            child.unref();
         }
     });
     child.on("error", (error) => {
         console.error(pc.red("Failed to start Xanix server"), error);
+        // write error to stderr log
+        writeFile(stderrFile, String(error), { flag: "a" }).catch(() => { });
     });
+    child.unref();
 };
 export default start;

package/dist/bin/finder/callbackReplacer.d.ts

@@ -0,0 +1,2 @@
+declare function callbackReplacer(code: string, name: string, replacer: (args: string[]) => string | void): string;
+export default callbackReplacer;

package/dist/bin/finder/callbackReplacer.js

@@ -0,0 +1,52 @@
+import { TOKENS } from "./stripComments.js";
+const mask = (code) => code.replace(TOKENS, (m) => /^["'`]/.test(m)
+    ? m[0] + m.slice(1, -1).replace(/[^\r\n]/g, " ") + m.at(-1)
+    : m.replace(/[^\r\n]/g, " "));
+function callbackReplacer(code, name, replacer) {
+    const masked = mask(code);
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`(?<![\\w$.])${escaped}\\s*\\(`, "g");
+    let result = "";
+    let last = 0;
+    let m;
+    while ((m = re.exec(masked))) {
+        const start = m.index;
+        const cs = re.lastIndex;
+        // find the matching ")"
+        let depth = 1;
+        let i = cs;
+        for (; i < masked.length && depth; i++) {
+            if (masked[i] === "(")
+                depth++;
+            else if (masked[i] === ")")
+                depth--;
+        }
+        if (depth)
+            break; // unbalanced: leave the rest untouched
+        const end = i - 1;
+        // split top-level args
+        const args = [];
+        let argStart = cs;
+        let d = 0;
+        for (let j = cs; j < end; j++) {
+            const c = masked[j];
+            if (c === "(" || c === "[" || c === "{")
+                d++;
+            else if (c === ")" || c === "]" || c === "}")
+                d--;
+            else if (c === "," && d === 0) {
+                args.push(code.slice(argStart, j).trim());
+                argStart = j + 1;
+            }
+        }
+        const tail = code.slice(argStart, end).trim();
+        if (tail)
+            args.push(tail);
+        result += code.slice(last, start);
+        const out = replacer(args);
+        result += out !== undefined ? out : code.slice(start, end + 1);
+        last = re.lastIndex = end + 1;
+    }
+    return result + code.slice(last);
+}
+export default callbackReplacer;

package/dist/bin/finder/findImport.d.ts

@@ -0,0 +1,9 @@
+export type ImportInfo = {
+    specifiers: {
+        local: string;
+        imported: string;
+    }[];
+    namespace?: string;
+};
+declare function importFinder(code: string, module: string): ImportInfo[];
+export default importFinder;

package/dist/bin/finder/findImport.js

@@ -0,0 +1,50 @@
+function importFinder(code, module) {
+    const esc = module.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const from = `(?:"${esc}"|'${esc}')`;
+    const found = [];
+    // import a, { b as c }, * as ns from "module"  (skips `import type ...`)
+    const importRe = new RegExp(`(?<![\\w$.])import(?![\\w$])(?!\\s+type\\s+[\\w$*{])\\s*([^;"']*?)\\s*from\\s*${from}`, "g");
+    for (const m of code.matchAll(importRe)) {
+        const clause = m[1];
+        const specifiers = [];
+        const namespace = /\*\s*as\s+([\w$]+)/.exec(clause)?.[1];
+        const named = /\{([^}]*)\}/.exec(clause)?.[1];
+        const def = clause
+            .replace(/\{[^}]*\}|\*\s*as\s+[\w$]+/g, "")
+            .replace(/,/g, "")
+            .trim();
+        if (/^[\w$]+$/.test(def))
+            specifiers.push({ local: def, imported: "default" });
+        for (const item of named?.split(",") ?? []) {
+            const s = item.trim();
+            if (!s || /^type\s+(?!as\s)/.test(s))
+                continue;
+            const [imported, local] = s.split(/\s+as\s+/).map((x) => x.trim());
+            specifiers.push({ local: local ?? imported, imported });
+        }
+        found.push({
+            index: m.index,
+            info: namespace ? { specifiers, namespace } : { specifiers },
+        });
+    }
+    // const a = require("module") / const { b, c: d } = require("module")
+    const requireRe = new RegExp(`(?<![\\w$.])(?:const|let|var)\\s+(?:([\\w$]+)|\\{([^}]*)\\})\\s*=\\s*require\\s*\\(\\s*${from}\\s*\\)(?![.(\\[])`, "g");
+    for (const m of code.matchAll(requireRe)) {
+        const specifiers = [];
+        if (m[1]) {
+            specifiers.push({ local: m[1], imported: "default" });
+        }
+        else {
+            for (const item of m[2].split(",")) {
+                const s = item.trim().replace(/\s*=[\s\S]*$/, ""); // drop defaults
+                if (!s || s.startsWith("..."))
+                    continue;
+                const [imported, local] = s.split(/\s*:\s*/).map((x) => x.trim());
+                specifiers.push({ local: local ?? imported, imported });
+            }
+        }
+        found.push({ index: m.index, info: { specifiers } });
+    }
+    return found.sort((a, b) => a.index - b.index).map((f) => f.info);
+}
+export default importFinder;

package/dist/bin/finder/findImports.d.ts

@@ -0,0 +1,16 @@
+export type ImportSpecifier = {
+    imported: string;
+    local: string;
+    typeOnly: boolean;
+};
+export type ImportRecord = {
+    source: string;
+    default?: string;
+    namespace?: string;
+    named: ImportSpecifier[];
+    typeOnly: boolean;
+    start: number;
+    end: number;
+};
+declare function findImports(code: string): ImportRecord[];
+export default findImports;

package/dist/bin/finder/findImports.js

@@ -0,0 +1,45 @@
+import { TOKENS } from "./stripComments.js";
+// Blank comments, regex literals and string/template contents (length preserved,
+// quote characters kept) so imports inside them are never matched.
+const mask = (code) => code.replace(TOKENS, (m) => /^["'`]/.test(m)
+    ? m[0] + m.slice(1, -1).replace(/[^\r\n]/g, " ") + m.at(-1)
+    : m.replace(/[^\r\n]/g, " "));
+const IMPORT_RE = /(?<![\w$.])(?<head>import(?![\w$])\s*)(?<pre>(?:(?<type>type\s+(?!from\b)(?=[\w$*{]))?(?<clause>[^;"'`]*?)\s*from\s*)?)(?<q>["'])(?<src>[^"']+)\k<q>(?:\s*(?:with|assert)\s*\{[^}]*\})?;?/g;
+function findImports(code) {
+    const records = [];
+    for (const m of mask(code).matchAll(IMPORT_RE)) {
+        const g = m.groups;
+        const srcStart = m.index + g.head.length + g.pre.length + 1;
+        const clause = g.clause ?? "";
+        const record = {
+            source: code.slice(srcStart, srcStart + g.src.length),
+            named: [],
+            typeOnly: !!g.type,
+            start: m.index,
+            end: m.index + m[0].length,
+        };
+        const namespace = /\*\s*as\s+([\w$]+)/.exec(clause)?.[1];
+        if (namespace)
+            record.namespace = namespace;
+        const named = /\{([^}]*)\}/.exec(clause)?.[1];
+        for (const item of named?.split(",") ?? []) {
+            let s = item.trim();
+            if (!s)
+                continue;
+            const typeOnly = /^type\s+(?!as\s)/.test(s);
+            if (typeOnly)
+                s = s.replace(/^type\s+/, "");
+            const [imported, local] = s.split(/\s+as\s+/).map((x) => x.trim());
+            record.named.push({ imported, local: local ?? imported, typeOnly });
+        }
+        const def = clause
+            .replace(/\{[^}]*\}|\*\s*as\s+[\w$]+/g, "")
+            .replace(/,/g, "")
+            .trim();
+        if (/^[\w$]+$/.test(def))
+            record.default = def;
+        records.push(record);
+    }
+    return records;
+}
+export default findImports;

package/dist/bin/finder/findPage.d.ts

@@ -0,0 +1,9 @@
+export type SendFinderResult = {
+    source: string;
+    identifier: string;
+    args: string[];
+    start: number;
+    end: number;
+};
+declare function pageFinder(code: string): SendFinderResult[];
+export default pageFinder;

package/dist/bin/finder/findPage.js

@@ -0,0 +1,30 @@
+import findImports from "./findImports.js";
+const ID = "[A-Za-z_$][\\w$]*";
+function pageFinder(code) {
+    // default imports only:
+    //   import Home from "./Home";
+    //   import Layout, { Header } from "./Layout";
+    //   import Components, * as UI from "./components";
+    const defaultImports = new Map();
+    for (const imp of findImports(code)) {
+        if (imp.default && !imp.typeOnly)
+            defaultImports.set(imp.default, imp.source);
+    }
+    // only: <identifier>.send(<Component />)
+    const sendRe = new RegExp(`(${ID}(?:\\??\\.${ID})*)\\??\\.send\\s*\\(\\s*(<([A-Z_$][\\w$]*)\\s*/>)\\s*\\)`, "g");
+    const results = [];
+    for (const m of code.matchAll(sendRe)) {
+        const source = defaultImports.get(m[3]);
+        if (!source)
+            continue;
+        results.push({
+            source,
+            identifier: m[1],
+            args: [m[2]],
+            start: m.index,
+            end: m.index + m[0].length,
+        });
+    }
+    return results;
+}
+export default pageFinder;

package/dist/bin/finder/importFinder.d.ts

@@ -0,0 +1,9 @@
+export type ImportInfo = {
+    specifiers: {
+        local: string;
+        imported: string;
+    }[];
+    namespace?: string;
+};
+declare function importFinder(code: string, module: string): ImportInfo[];
+export default importFinder;