xanix 1.0.4 → 1.0.7

package/package.json

@@ -1,73 +1,75 @@
-{
-  "name": "xanix",
-  "version": "1.0.4",
-  "description": "",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "./dist/index.d.ts",
-  "bin": "./dist/bin/index.js",
-  "type": "module",
-  "files": [
-    "dist",
-    "xanix-env.d.ts"
-  ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    },
-    "./page": {
-      "import": "./dist/server/page.js",
-      "require": "./dist/server/page.js"
-    },
-    "./runtime": {
-      "import": "./dist/server/runtime/index.js",
-      "require": "./dist/server/runtime/index.js"
-    }
-  },
-  "scripts": {
-    "dev": "tsc --watch --preserveWatchOutput",
-    "build": "tsc",
-    "start": "node dist/index.js"
-  },
-  "keywords": [],
-  "author": "Naxrul Ahmed",
-  "license": "ISC",
-  "dependencies": {
-    "@babel/generator": "^8.0.0",
-    "@babel/parser": "^8.0.4",
-    "@babel/traverse": "^8.0.4",
-    "@rollup/plugin-alias": "^6.0.0",
-    "@rollup/plugin-commonjs": "^29.0.3",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-replace": "^6.0.3",
-    "@rollup/plugin-url": "^8.0.2",
-    "commander": "^15.0.0",
-    "dotenv": "^17.4.2",
-    "esbuild": "^0.28.2",
-    "express": "^5.2.1",
-    "picocolors": "^1.1.1",
-    "react-refresh": "^0.18.0",
-    "rollup": "^4.62.5",
-    "rollup-plugin-esbuild": "^6.2.1",
-    "tslib": "^2.8.1",
-    "ws": "^8.21.3"
-  },
-  "devDependencies": {
-    "@types/babel__core": "^7.20.5",
-    "@types/express": "^5.0.6",
-    "@types/node": "^26.2.0",
-    "@types/prompts": "^2.4.9",
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
-    "@types/react-refresh": "^0.14.7",
-    "@types/ws": "^8.18.1",
-    "@xanui/core": "^1.3.38",
-    "@xanui/icons": "^1.1.14",
-    "@xanui/ui": "^1.2.24",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "xanix",
+  "version": "1.0.7",
+  "description": "",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": "./dist/bin/index.js",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./page": {
+      "import": "./dist/server/page.js",
+      "require": "./dist/server/page.js"
+    },
+    "./runtime": {
+      "import": "./dist/server/runtime/index.js",
+      "require": "./dist/server/runtime/index.js"
+    },
+    "./BaseDocument": {
+      "types": "./dist/components/BaseDocument.d.ts",
+      "import": "./dist/components/BaseDocument.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsc --watch --preserveWatchOutput",
+    "build": "tsc && node scripts/build-types.js"
+  },
+  "keywords": [],
+  "author": "Naxrul Ahmed",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/generator": "^8.0.0",
+    "@babel/parser": "^8.0.4",
+    "@babel/traverse": "^8.0.4",
+    "@rollup/plugin-alias": "^6.0.0",
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-url": "^8.0.2",
+    "commander": "^15.0.0",
+    "dotenv": "^17.4.2",
+    "esbuild": "^0.28.2",
+    "express": "^5.2.1",
+    "picocolors": "^1.1.1",
+    "react-refresh": "^0.18.0",
+    "rollup": "^4.62.5",
+    "rollup-plugin-esbuild": "^6.2.1",
+    "tslib": "^2.8.1",
+    "ws": "^8.21.3"
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.2.0",
+    "@types/prompts": "^2.4.9",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@types/react-refresh": "^0.14.7",
+    "@types/ws": "^8.18.1",
+    "@xanui/core": "^1.3.38",
+    "@xanui/icons": "^1.1.14",
+    "@xanui/ui": "^1.2.24",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "typescript": "^5.9.3"
+  }
+}

package/dist/BaseDocument.d.ts

@@ -1,3 +0,0 @@
-import { DocumentProps } from "./components/Document/index.js";
-declare const BaseDocument: ({ document, children }: DocumentProps) => import("react").JSX.Element;
-export default BaseDocument;

package/dist/BaseDocument.js

@@ -1,8 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import Head from "./components/Head.js";
-import Body from "./components/Body.js";
-import Document from "./components/Document/index.js";
-const BaseDocument = ({ document, children }) => {
-    return (_jsxs(Document, { document: document, children: [_jsxs(Head, { children: [_jsx("meta", { charSet: "UTF-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" })] }), _jsx(Body, { children: children })] }));
-};
-export default BaseDocument;

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

@@ -1,11 +0,0 @@
-import { XanixClientEntry } from "../types";
-export type DependencyInfo = {
-    source: string;
-    resolved: string;
-    packageName: string;
-};
-export type CacheMetadata = Map<string, {
-    file: string;
-}>;
-declare const BuildCache: (entries: XanixClientEntry[]) => Promise<CacheMetadata>;
-export default BuildCache;

package/dist/bin/bundler/buildCache.js

@@ -1,112 +0,0 @@
-import path from "node:path";
-import { rollup } from "rollup";
-import { build } from "esbuild";
-import { createRequire } from "node:module";
-import xanixAssets from "./plugins/XanixAssets/index.js";
-import rollupEsbuild from "./plugins/rollupEsbuild.js";
-import { getDocumentFile } from "../include/utils.js";
-const require = createRequire(import.meta.url);
-const GenerateGraph = async (entries) => {
-    const collector = new Map();
-    const input = {};
-    for (const entry of entries) {
-        input[entry.name] = entry.file;
-    }
-    input["xanix-runtime"] = require.resolve("xanix/runtime");
-    input["xanix-document"] = await getDocumentFile();
-    const bundle = await rollup({
-        input,
-        plugins: [
-            xanixAssets({
-                external: true,
-            }),
-            rollupEsbuild({
-                sourceMap: true,
-            }),
-        ],
-        external(id) {
-            if (id.startsWith(".") || path.isAbsolute(id)) {
-                return false;
-            }
-            collector.set(id, {
-                source: id,
-                resolved: require.resolve(id, {
-                    paths: [process.cwd()],
-                }),
-                packageName: id,
-            });
-            return true;
-        },
-    });
-    await bundle.close();
-    return collector;
-};
-// Wraps each CJS dep in a virtual ESM file that re-exports named exports detected via require()
-const makeCjsWrapperPlugin = (wrappers) => ({
-    name: "cjs-named-exports",
-    setup(build) {
-        build.onResolve({ filter: /\?cjs-wrapper$/ }, (args) => ({
-            path: args.path,
-            namespace: "cjs-wrapper",
-        }));
-        build.onLoad({ filter: /.*/, namespace: "cjs-wrapper" }, (args) => {
-            const contents = wrappers.get(args.path);
-            return { contents, resolveDir: process.cwd() };
-        });
-    },
-});
-const buildWrappers = (input) => {
-    const wrappers = new Map();
-    const wrappedInput = {};
-    for (const [name, resolved] of Object.entries(input)) {
-        const key = `${name}?cjs-wrapper`;
-        let namedExports = [];
-        try {
-            const mod = require(resolved);
-            namedExports = Object.keys(mod).filter((k) => k !== "__esModule" && k !== "default");
-        }
-        catch { }
-        const lines = [
-            `import __mod from ${JSON.stringify(resolved)};`,
-            `export default __mod;`,
-        ];
-        if (namedExports.length > 0) {
-            lines.push(`export const { ${namedExports.join(", ")} } = __mod;`);
-        }
-        wrappers.set(key, lines.join("\n"));
-        wrappedInput[name] = key;
-    }
-    return { wrappers, wrappedInput };
-};
-const bundleDeps = async (input, outdir) => {
-    const { wrappers, wrappedInput } = buildWrappers(input);
-    await build({
-        entryPoints: wrappedInput,
-        bundle: true,
-        splitting: true,
-        format: "esm",
-        target: "es2022",
-        outdir,
-        entryNames: "[name]",
-        chunkNames: "chunks/[hash]",
-        platform: "browser",
-        sourcemap: true,
-        plugins: [makeCjsWrapperPlugin(wrappers)],
-    });
-};
-const metadata = new Map();
-const BuildCache = async (entries) => {
-    const input = {};
-    const dependencies = await GenerateGraph(entries);
-    for (const dependency of dependencies.values()) {
-        const entryName = dependency.source.replace(/^@/, "").replace(/\//g, "-");
-        input[entryName] = dependency.resolved;
-        metadata.set(dependency.source, {
-            file: `${entryName}.js`,
-        });
-    }
-    const cacheDir = path.resolve(process.cwd(), ".xanix/cache");
-    await bundleDeps(input, cacheDir);
-    return metadata;
-};
-export default BuildCache;

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

@@ -1,4 +0,0 @@
-declare const xanixAssets: (options?: {
-    external: boolean;
-}) => import("rollup").Plugin<any>;
-export default xanixAssets;

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

@@ -1,22 +0,0 @@
-import url from "@rollup/plugin-url";
-const xanixAssets = (options) => {
-    return url({
-        include: [
-            "**/*.jpg",
-            "**/*.jpeg",
-            "**/*.png",
-            "**/*.gif",
-            "**/*.webp",
-            "**/*.svg",
-            "**/*.ico",
-            "**/*.woff",
-            "**/*.woff2",
-            "**/*.ttf",
-            "**/*.eot",
-        ],
-        limit: 0,
-        fileName: "assets/[name]-[hash][extname]",
-        emitFiles: !(options?.external ?? false),
-    });
-};
-export default xanixAssets;

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

@@ -1,6 +0,0 @@
-import type { Plugin } from "rollup";
-export interface XanixBrowserCodeOptions {
-    target?: "server" | "client";
-    globals?: string[];
-}
-export default function xanixBrowserCodeRemover(options?: XanixBrowserCodeOptions): Plugin;

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

@@ -1,350 +0,0 @@
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import generate from "@babel/generator";
-import * as t from "@babel/types";
-const DEFAULT_BROWSER_GLOBALS = [
-    "window",
-    "document",
-    "localStorage",
-    "sessionStorage",
-    "navigator",
-    "location",
-    "history",
-    "screen",
-    "indexedDB",
-    "caches",
-    "WebSocket",
-    "File",
-    "FileReader",
-    "Blob",
-    "FormData",
-    "EventSource",
-    "Worker",
-    "SharedWorker",
-    "IntersectionObserver",
-    "ResizeObserver",
-    "MutationObserver",
-    "PerformanceObserver",
-    "Notification",
-    "BroadcastChannel",
-    "MessageChannel",
-    "MessageEvent",
-    "URL",
-    "URLSearchParams",
-    "MediaSource",
-    "MediaRecorder",
-    "Audio",
-    "Image",
-    "HTMLImageElement",
-];
-export default function xanixBrowserCodeRemover(options = {}) {
-    const { target = "server", globals = DEFAULT_BROWSER_GLOBALS } = options;
-    const browserGlobals = new Set(globals);
-    return {
-        name: "xanix-browser-code-remover",
-        transform(code, id) {
-            if (target !== "server") {
-                return null;
-            }
-            if (id.includes("/node_modules/") || id.includes("\\node_modules\\")) {
-                return null;
-            }
-            if (!/\.(?:[cm]?[jt]sx?)$/.test(id)) {
-                return null;
-            }
-            const ast = parse(code, {
-                sourceType: "module",
-                plugins: [
-                    "jsx",
-                    "typescript",
-                    // "decorators-legacy",
-                    // "classProperties",
-                    // "classPrivateProperties",
-                    // "classPrivateMethods",
-                    // "optionalChaining",
-                    // "nullishCoalescingOperator",
-                    // "dynamicImport",
-                    // "topLevelAwait",
-                ],
-            });
-            const removePaths = new Set();
-            const replacePaths = new Set();
-            function isBrowserGlobal(path) {
-                const name = path.node.name;
-                if (!browserGlobals.has(name)) {
-                    return false;
-                }
-                if (!path.isReferencedIdentifier()) {
-                    return false;
-                }
-                // Don't transform locally declared variables.
-                if (path.scope.getBinding(name)) {
-                    return false;
-                }
-                return true;
-            }
-            function containsBrowserGlobal(path) {
-                let found = false;
-                path.traverse({
-                    Identifier(innerPath) {
-                        if (found) {
-                            return;
-                        }
-                        if (isBrowserGlobal(innerPath)) {
-                            found = true;
-                        }
-                    },
-                });
-                return found;
-            }
-            function getBrowserExpression(path) {
-                let current = path;
-                while (current.parentPath) {
-                    const parent = current.parentPath;
-                    /*
-                     * window.foo
-                     * window.foo.bar
-                     * window["foo"]
-                     */
-                    if (parent.isMemberExpression() ||
-                        parent.isOptionalMemberExpression()) {
-                        current = parent;
-                        continue;
-                    }
-                    /*
-                     * window.foo()
-                     * window.foo.bar()
-                     */
-                    if (parent.isCallExpression() || parent.isOptionalCallExpression()) {
-                        const callee = parent.get("callee");
-                        if (!Array.isArray(callee) && callee.node === current.node) {
-                            current = parent;
-                            continue;
-                        }
-                        break;
-                    }
-                    /*
-                     * window.foo!
-                     */
-                    if (parent.isTSNonNullExpression()) {
-                        current = parent;
-                        continue;
-                    }
-                    /*
-                     * window.foo as Something
-                     */
-                    if (parent.isTSAsExpression()) {
-                        current = parent;
-                        continue;
-                    }
-                    break;
-                }
-                return current;
-            }
-            function findContainingStatement(path) {
-                let current = path;
-                while (current.parentPath) {
-                    const parent = current.parentPath;
-                    if (parent.isExpressionStatement()) {
-                        return parent;
-                    }
-                    if (parent.isFunctionDeclaration() ||
-                        parent.isFunctionExpression() ||
-                        parent.isArrowFunctionExpression()) {
-                        return null;
-                    }
-                    current = parent;
-                }
-                return null;
-            }
-            function markRemove(path) {
-                if (!path.removed) {
-                    removePaths.add(path);
-                }
-            }
-            function markReplace(path) {
-                if (!path.removed) {
-                    replacePaths.add(path);
-                }
-            }
-            traverse(ast, {
-                /*
-                 * ---------------------------------------------------------
-                 * JSX
-                 *
-                 * <div>{window.innerWidth}</div>
-                 *
-                 * ->
-                 *
-                 * <div>{undefined}</div>
-                 * ---------------------------------------------------------
-                 */
-                JSXExpressionContainer(path) {
-                    const expression = path.get("expression");
-                    if (!expression || Array.isArray(expression)) {
-                        return;
-                    }
-                    if (expression.isJSXEmptyExpression()) {
-                        return;
-                    }
-                    if (!expression.isExpression()) {
-                        return;
-                    }
-                    if (!containsBrowserGlobal(expression)) {
-                        return;
-                    }
-                    markReplace(expression);
-                },
-                /*
-                 * ---------------------------------------------------------
-                 * Standalone browser statements
-                 *
-                 * window.addEventListener(...)
-                 * document.title = "Xanix"
-                 * localStorage.setItem(...)
-                 *
-                 * ->
-                 *
-                 * removed
-                 * ---------------------------------------------------------
-                 */
-                ExpressionStatement(path) {
-                    if (!containsBrowserGlobal(path)) {
-                        return;
-                    }
-                    markRemove(path);
-                },
-                /*
-                 * ---------------------------------------------------------
-                 * Variable declarations
-                 *
-                 * const width = window.innerWidth;
-                 *
-                 * ->
-                 *
-                 * const width = undefined;
-                 * ---------------------------------------------------------
-                 */
-                VariableDeclarator(path) {
-                    const init = path.get("init");
-                    if (!init || Array.isArray(init)) {
-                        return;
-                    }
-                    if (!init.isExpression()) {
-                        return;
-                    }
-                    if (!containsBrowserGlobal(init)) {
-                        return;
-                    }
-                    markReplace(init);
-                },
-                /*
-                 * ---------------------------------------------------------
-                 * Return
-                 *
-                 * return window.innerWidth;
-                 *
-                 * ->
-                 *
-                 * return undefined;
-                 * ---------------------------------------------------------
-                 */
-                ReturnStatement(path) {
-                    const argument = path.get("argument");
-                    if (!argument || Array.isArray(argument)) {
-                        return;
-                    }
-                    if (!argument.isExpression()) {
-                        return;
-                    }
-                    if (!containsBrowserGlobal(argument)) {
-                        return;
-                    }
-                    markReplace(argument);
-                },
-                /*
-                 * ---------------------------------------------------------
-                 * Identifier
-                 * ---------------------------------------------------------
-                 */
-                Identifier(path) {
-                    if (!isBrowserGlobal(path)) {
-                        return;
-                    }
-                    const browserExpression = getBrowserExpression(path);
-                    /*
-                     * JSXExpressionContainer is handled above.
-                     */
-                    if (browserExpression.parentPath?.isJSXExpressionContainer()) {
-                        return;
-                    }
-                    /*
-                     * Example:
-                     *
-                     * window.addEventListener(...)
-                     *
-                     * Remove the complete statement.
-                     */
-                    const statement = findContainingStatement(browserExpression);
-                    if (statement) {
-                        markRemove(statement);
-                        return;
-                    }
-                    const parent = browserExpression.parentPath;
-                    /*
-                     * Variable initializer:
-                     *
-                     * const x = window.foo;
-                     */
-                    if (parent?.isVariableDeclarator()) {
-                        markReplace(browserExpression);
-                        return;
-                    }
-                    /*
-                     * Return:
-                     *
-                     * return window.foo;
-                     */
-                    if (parent?.isReturnStatement()) {
-                        markReplace(browserExpression);
-                        return;
-                    }
-                    /*
-                     * General expression:
-                     *
-                     * console.log(window.innerWidth)
-                     *
-                     * ->
-                     *
-                     * console.log(undefined)
-                     */
-                    markReplace(browserExpression);
-                },
-            });
-            /*
-             * Remove first.
-             */
-            for (const path of removePaths) {
-                if (!path.removed) {
-                    path.remove();
-                }
-            }
-            /*
-             * Replace second.
-             */
-            for (const path of replacePaths) {
-                if (!path.removed) {
-                    path.replaceWith(t.identifier("undefined"));
-                }
-            }
-            const output = generate(ast, {
-                sourceMaps: true,
-                sourceFileName: id,
-            }, code);
-            return {
-                code: output.code,
-                map: output.map,
-            };
-        },
-    };
-}