xanix 1.0.19 → 1.0.21

package/dist/bin/finder/importFinder.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/pageFinder.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/pageFinder.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/stripComments.d.ts

@@ -0,0 +1,3 @@
+export declare const TOKENS: RegExp;
+declare function stripComments(code: string): string;
+export default stripComments;

package/dist/bin/finder/stripComments.js

@@ -0,0 +1,15 @@
+const STRING = /"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'/;
+// template literal: allows `${ ... }` with strings/templates inside (no nested braces),
+// falls back to a plain backtick string
+const TEMPLATE = /`(?:\\[\s\S]|\$\{(?:[^{}`]|`(?:\\[\s\S]|[^`\\])*`)*\}|[^`\\$]|\$(?!\{))*`|`(?:\\[\s\S]|[^`\\])*`/;
+// regex literal: only where a regex can legally start (after an operator,
+// opening bracket, keyword or start of file), and `/` allowed inside [...]
+const REGEX = /(?<=(?:^|[(,=:[!&|?{};<>~^%*]|\b(?:return|typeof|case|void|delete|throw|yield|await|in|of))\s*)\/(?![/*])(?:\\.|\[(?:\\.|[^\]\\\r\n])*\]|[^/\\\r\n[])+\/[dgimsuvy]*/;
+const COMMENT = /\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/;
+export const TOKENS = new RegExp([STRING, TEMPLATE, REGEX, COMMENT].map((r) => r.source).join("|"), "g");
+function stripComments(code) {
+    return code.replace(TOKENS, (m) => m[0] === "/" && (m[1] === "/" || m[1] === "*")
+        ? m.replace(/[^\r\n]/g, " ")
+        : m);
+}
+export default stripComments;

package/dist/bin/include/path.d.ts

@@ -1 +1,5 @@
-export declare const frameworkDir: string;
+export declare const xanixHome: string;
+export declare const xanixProcesses: string;
+export declare const xanixLogs: string;
+export declare const xanixSaved: string;
+export declare const framworkDir: string;

package/dist/bin/include/path.js

@@ -1,4 +1,18 @@
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export const frameworkDir = path.resolve(__dirname, "../../../");
+const homeDir = os.homedir();
+export const xanixHome = (() => {
+    if (process.platform === "win32") {
+        return path.join(process.env.LOCALAPPDATA || path.join(homeDir, "AppData", "Local"), "Xanix");
+    }
+    if (process.platform === "darwin") {
+        return path.join(homeDir, "Library", "Application Support", "Xanix");
+    }
+    return path.join(process.env.XDG_STATE_HOME || path.join(homeDir, ".local", "state"), "xanix");
+})();
+export const xanixProcesses = path.join(xanixHome, "processes");
+export const xanixLogs = path.join(xanixHome, "logs");
+export const xanixSaved = path.join(xanixHome, "saved");
+export const framworkDir = path.resolve(__dirname, "../../../");

package/dist/bin/include/sendFinder.d.ts

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

package/dist/bin/include/sendFinder.js

@@ -1,40 +1,29 @@
-function sendFinder(code) {
+export function sendFinder(code) {
     const results = [];
-    // Find imports first.
-    const imports = new Map();
-    const importRegex = /import\s+(?:(\w+)\s*,?\s*)?(?:\{\s*([^}]+)\s*\})?\s*from\s*["']([^"']+)["']/g;
-    for (const match of code.matchAll(importRegex)) {
-        const defaultName = match[1];
-        const named = match[2];
-        const file = match[3];
-        if (defaultName) {
-            imports.set(defaultName, file);
-        }
-        if (named) {
-            for (const item of named.split(",")) {
-                const [imported, local = imported] = item.trim().split(/\s+as\s+/);
-                imports.set(local, file);
-            }
-        }
-    }
-    // import * as Pages from "./pages"
-    const namespaceRegex = /import\s+\*\s+as\s+(\w+)\s+from\s*["']([^"']+)["']/g;
-    for (const match of code.matchAll(namespaceRegex)) {
-        imports.set(match[1], match[2]);
-    }
-    // Find:
+    // Only store DEFAULT imports.
     //
-    // res.send(<Home />)
-    // response.send(<Layout />)
-    // ctx.send(<Pages.Home />)
+    // import Home from "./Home";
+    // import Layout, { Header } from "./Layout";
+    // import Components, * as UI from "./components";
     //
-    const sendRegex = /(\w+(?:\.\w+)?)\.send\s*\(/g;
+    // Does NOT store:
+    // import { Layout } from "./Layout";
+    // import * as Pages from "./pages";
+    const defaultImports = new Map();
+    const defaultImportRegex = /import\s+([A-Za-z_$][\w$]*)\s*(?:,\s*(?:\{[^}]*\}|\*\s+as\s+[A-Za-z_$][\w$]*))?\s+from\s*["']([^"']+)["']/g;
+    for (const match of code.matchAll(defaultImportRegex)) {
+        const local = match[1];
+        const file = match[2];
+        defaultImports.set(local, file);
+    }
+    const sendRegex = /([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\.send\s*\(/g;
     let match;
     while ((match = sendRegex.exec(code))) {
-        const identifier = `${match[1]}.send`;
-        const contentStart = sendRegex.lastIndex;
+        const identifier = `${match[1]}`;
+        const start = match.index;
+        const argsStart = sendRegex.lastIndex;
         let depth = 1;
-        let i = contentStart;
+        let i = argsStart;
         let quote = null;
         for (; i < code.length; i++) {
             const char = code[i];
@@ -61,40 +50,86 @@ function sendFinder(code) {
                 }
             }
         }
-        const argument = code.slice(contentStart, i).trim();
-        // Must start with JSX.
-        if (!argument.startsWith("<")) {
+        if (depth !== 0) {
+            break;
+        }
+        const end = i + 1;
+        const content = code.slice(argsStart, i);
+        const args = splitArguments(content);
+        const firstArg = args[0]?.trim();
+        if (!firstArg?.startsWith("<")) {
             continue;
         }
         // <Home />
         // <Home>
-        // <Pages.Home />
-        const jsxMatch = argument.match(/^<([A-Z_$][\w$]*(?:\.[A-Z_$][\w$]*)?)/);
+        const jsxMatch = firstArg.match(/^<([A-Z_$][\w$]*)/);
         if (!jsxMatch) {
             continue;
         }
         const component = jsxMatch[1];
-        // Home
-        if (!component.includes(".")) {
-            const file = imports.get(component);
-            if (file) {
-                results.push({
-                    file,
-                    identifier,
-                });
+        const file = defaultImports.get(component);
+        if (!file) {
+            continue;
+        }
+        results.push({
+            file,
+            identifier,
+            args,
+            start,
+            end,
+        });
+    }
+    return results;
+}
+function splitArguments(code) {
+    const args = [];
+    let start = 0;
+    let paren = 0;
+    let brace = 0;
+    let bracket = 0;
+    let quote = null;
+    for (let i = 0; i < code.length; i++) {
+        const char = code[i];
+        if (quote) {
+            if (char === "\\") {
+                i++;
             }
+            else if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"' || char === "`") {
+            quote = char;
             continue;
         }
-        // Pages.Home
-        const namespace = component.split(".")[0];
-        const file = imports.get(namespace);
-        if (file) {
-            results.push({
-                file,
-                identifier,
-            });
+        if (char === "(") {
+            paren++;
+        }
+        else if (char === ")") {
+            paren--;
+        }
+        else if (char === "{") {
+            brace++;
+        }
+        else if (char === "}") {
+            brace--;
+        }
+        else if (char === "[") {
+            bracket++;
+        }
+        else if (char === "]") {
+            bracket--;
+        }
+        else if (char === "," && paren === 0 && brace === 0 && bracket === 0) {
+            args.push(code.slice(start, i).trim());
+            start = i + 1;
         }
     }
-    return results;
+    const last = code.slice(start).trim();
+    if (last) {
+        args.push(last);
+    }
+    return args;
 }
 export default sendFinder;

package/dist/bin/modifier/callbackReplacer.js

@@ -1,96 +1,51 @@
+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 regex = new RegExp(`${escaped}\\(`, "g");
+    const re = new RegExp(`(?<![\\w$.])${escaped}\\s*\\(`, "g");
     let result = "";
     let last = 0;
-    let match;
-    while ((match = regex.exec(code))) {
-        const start = match.index;
-        const contentStart = regex.lastIndex;
+    let m;
+    while ((m = re.exec(masked))) {
+        const start = m.index;
+        const cs = re.lastIndex;
+        // find the matching ")"
         let depth = 1;
-        let i = contentStart;
-        let quote = null;
-        for (; i < code.length; i++) {
-            const char = code[i];
-            if (quote) {
-                if (char === "\\") {
-                    i++;
-                }
-                else if (char === quote) {
-                    quote = null;
-                }
-                continue;
-            }
-            if (char === "'" || char === '"' || char === "`") {
-                quote = char;
-                continue;
-            }
-            if (char === "(") {
+        let i = cs;
+        for (; i < masked.length && depth; i++) {
+            if (masked[i] === "(")
                 depth++;
-            }
-            else if (char === ")") {
+            else if (masked[i] === ")")
                 depth--;
-                if (depth === 0) {
-                    break;
-                }
-            }
-        }
-        if (depth !== 0) {
-            break;
         }
-        const content = code.slice(contentStart, i);
+        if (depth)
+            break; // unbalanced: leave the rest untouched
+        const end = i - 1;
+        // split top-level args
         const args = [];
-        let argStart = 0;
-        let paren = 0;
-        let brace = 0;
-        let bracket = 0;
-        quote = null;
-        for (let j = 0; j < content.length; j++) {
-            const char = content[j];
-            if (quote) {
-                if (char === "\\") {
-                    j++;
-                }
-                else if (char === quote) {
-                    quote = null;
-                }
-                continue;
-            }
-            if (char === "'" || char === '"' || char === "`") {
-                quote = char;
-                continue;
-            }
-            if (char === "(")
-                paren++;
-            else if (char === ")")
-                paren--;
-            else if (char === "{")
-                brace++;
-            else if (char === "}")
-                brace--;
-            else if (char === "[")
-                bracket++;
-            else if (char === "]")
-                bracket--;
-            if (char === "," && paren === 0 && brace === 0 && bracket === 0) {
-                args.push(content.slice(argStart, j).trim());
+        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 lastArg = content.slice(argStart).trim();
-        if (lastArg) {
-            args.push(lastArg);
-        }
+        const tail = code.slice(argStart, end).trim();
+        if (tail)
+            args.push(tail);
         result += code.slice(last, start);
-        const replaced = replacer(args);
-        if (replaced !== undefined) {
-            result += replaced;
-        }
-        else {
-            result += code.slice(start, i + 1);
-        }
-        last = i + 1;
-        regex.lastIndex = i + 1;
+        const out = replacer(args);
+        result += out !== undefined ? out : code.slice(start, end + 1);
+        last = re.lastIndex = end + 1;
     }
     return result + code.slice(last);
 }

package/dist/bin/modifier/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/modifier/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/modifier/importFinder.js

@@ -1,69 +1,50 @@
 function importFinder(code, module) {
-    const result = [];
-    const escaped = module.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    // import { foo, bar as baz } from "module"
-    const namedImport = new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*["']${escaped}["']`, "g");
-    const destructuredRequire = new RegExp(`(?:const|let|var)\\s*\\{([^}]*)\\}\\s*=\\s*require\\s*\\(\\s*["']${escaped}["']\\s*\\)`, "g");
-    for (const match of code.matchAll(destructuredRequire)) {
-        const specifiers = match[1]
-            .split(",")
-            .map((item) => item.trim())
-            .filter(Boolean)
-            .map((item) => {
-            const [imported, local] = item.split(/\s*:\s*/).map((x) => x.trim());
-            return {
-                local: local ?? imported,
-                imported,
-            };
+    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 },
         });
-        result.push({ specifiers });
     }
-    for (const match of code.matchAll(namedImport)) {
-        const specifiers = match[1]
-            .split(",")
-            .map((item) => item.trim())
-            .filter(Boolean)
-            .map((item) => {
-            const [imported, local] = item.split(/\s+as\s+/).map((x) => x.trim());
-            return {
-                local: local ?? imported,
-                imported,
-            };
-        });
-        result.push({ specifiers });
-    }
-    // import foo, { bar } from "module"
-    const defaultImport = new RegExp(`import\\s+([\\w$]+)\\s+from\\s*["']${escaped}["']`, "g");
-    for (const match of code.matchAll(defaultImport)) {
-        result.push({
-            specifiers: [
-                {
-                    local: match[1],
-                    imported: "default",
-                },
-            ],
-        });
-    }
-    // import * as foo from "module"
-    const namespaceImport = new RegExp(`import\\s*\\*\\s*as\\s*([\\w$]+)\\s*from\\s*["']${escaped}["']`, "g");
-    for (const match of code.matchAll(namespaceImport)) {
-        result.push({
-            specifiers: [],
-            namespace: match[1],
-        });
-    }
-    // const foo = require("module")
-    const requireImport = new RegExp(`(?:const|let|var)\\s+([\\w$]+)\\s*=\\s*require\\s*\\(\\s*["']${escaped}["']\\s*\\)`, "g");
-    for (const match of code.matchAll(requireImport)) {
-        result.push({
-            specifiers: [
-                {
-                    local: match[1],
-                    imported: "default",
-                },
-            ],
-        });
+    // 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 result;
+    return found.sort((a, b) => a.index - b.index).map((f) => f.info);
 }
 export default importFinder;

package/dist/bin/modifier/pageFinder.d.ts

@@ -1,4 +1,4 @@
-type SendFinderResult = {
+export type SendFinderResult = {
     source: string;
     identifier: string;
     args: string[];