@lunatest/react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Coco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/LunaTestProvider.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { LunaProvider, type LunaProviderOptions } from "@lunatest/core";
+export type LunaTestContextValue = {
+    provider: LunaProvider;
+    scenarioId?: string;
+    setScenarioId: (value?: string) => void;
+};
+export declare const LunaTestContext: React.Context<LunaTestContextValue | null>;
+export type LunaTestProviderProps = {
+    provider?: LunaProvider;
+    options?: LunaProviderOptions;
+    initialScenarioId?: string;
+    children?: React.ReactNode;
+};
+export declare function LunaTestProvider(props: LunaTestProviderProps): React.FunctionComponentElement<React.ProviderProps<LunaTestContextValue | null>>;

package/dist/LunaTestProvider.js

@@ -0,0 +1,18 @@
+import React, { createContext, useMemo, useState } from "react";
+import { createLunaProvider } from "./luna-provider.js";
+export const LunaTestContext = createContext(null);
+export function LunaTestProvider(props) {
+    const [scenarioId, setScenarioId] = useState(props.initialScenarioId);
+    const provider = useMemo(() => {
+        if (props.provider) {
+            return props.provider;
+        }
+        return createLunaProvider(props.options ?? {});
+    }, [props.provider, props.options]);
+    const value = useMemo(() => ({
+        provider,
+        scenarioId,
+        setScenarioId,
+    }), [provider, scenarioId]);
+    return React.createElement(LunaTestContext.Provider, { value }, props.children);
+}

package/dist/adapters/ethers.d.ts

@@ -0,0 +1,5 @@
+import { type LunaProvider } from "@lunatest/core";
+export type EthersLikeProvider = {
+    send: (method: string, params?: unknown[]) => Promise<unknown>;
+};
+export declare function createEthersAdapter(provider: LunaProvider): EthersLikeProvider;

package/dist/adapters/ethers.js

@@ -0,0 +1,10 @@
+export function createEthersAdapter(provider) {
+    return {
+        send(method, params = []) {
+            return provider.request({
+                method,
+                params,
+            });
+        },
+    };
+}

package/dist/adapters/wagmi.d.ts

@@ -0,0 +1,18 @@
+import { type LunaProvider } from "@lunatest/core";
+type Eip1193RequestLike = {
+    method: string;
+    params?: unknown[];
+};
+type WagmiLikeChain = {
+    id: number;
+};
+type WagmiLikeTransport = {
+    type: "luna";
+    request: (payload: Eip1193RequestLike) => Promise<unknown>;
+};
+export type WagmiLikeConfig = {
+    chains?: WagmiLikeChain[];
+    transports?: Record<number, WagmiLikeTransport>;
+};
+export declare function withLunaWagmiConfig(config: WagmiLikeConfig, provider: LunaProvider): WagmiLikeConfig;
+export {};

package/dist/adapters/wagmi.js

@@ -0,0 +1,14 @@
+export function withLunaWagmiConfig(config, provider) {
+    const chainIds = (config.chains ?? [{ id: 1 }]).map((chain) => chain.id);
+    const transports = { ...(config.transports ?? {}) };
+    for (const chainId of chainIds) {
+        transports[chainId] = {
+            type: "luna",
+            request: (payload) => provider.request(payload),
+        };
+    }
+    return {
+        ...config,
+        transports,
+    };
+}

package/dist/adapters/web3js.d.ts

@@ -0,0 +1,10 @@
+import { type LunaProvider } from "@lunatest/core";
+type RequestPayload = {
+    method: string;
+    params?: unknown[];
+};
+export type Web3JsLikeProvider = {
+    request: (payload: RequestPayload) => Promise<unknown>;
+};
+export declare function createWeb3JsAdapter(provider: LunaProvider): Web3JsLikeProvider;
+export {};

package/dist/adapters/web3js.js

@@ -0,0 +1,7 @@
+export function createWeb3JsAdapter(provider) {
+    return {
+        request(payload) {
+            return provider.request(payload);
+        },
+    };
+}

package/dist/bootstrap.d.ts

@@ -0,0 +1,15 @@
+import type { LuaConfig } from "@lunatest/core";
+import { type LunaRuntimeInterceptConfig } from "@lunatest/runtime-intercept";
+export type LunaBootstrapOptions = {
+    source?: string | URL;
+    nodeEnv?: string;
+    mountDevtools?: boolean;
+    devtoolsTargetId?: string;
+    configOverride?: Partial<LunaRuntimeInterceptConfig>;
+};
+export type LunaBootstrapResult = {
+    enabled: boolean;
+    unmountDevtools?: () => void;
+    config: LuaConfig;
+};
+export declare function bootstrapLunaRuntime(options?: LunaBootstrapOptions): Promise<LunaBootstrapResult>;

package/dist/bootstrap.js

@@ -0,0 +1,48 @@
+import { loadLunaConfig } from "@lunatest/core";
+import { applyInterceptState, enableLunaRuntimeIntercept, setRouteMocks, } from "@lunatest/runtime-intercept";
+import { mountLunaDevtools } from "./devtools/mount.js";
+import { resolveNodeEnv } from "./node-env.js";
+function toRuntimeConfig(config, configOverride) {
+    return {
+        ...configOverride,
+        intercept: {
+            ...configOverride?.intercept,
+            mode: configOverride?.intercept?.mode ?? config.mode,
+            mockResponses: {
+                ...(config.intercept?.mockResponses ?? {}),
+                ...(configOverride?.intercept?.mockResponses ?? {}),
+            },
+        },
+    };
+}
+export async function bootstrapLunaRuntime(options = {}) {
+    const config = await loadLunaConfig(options.source ?? "./lunatest.lua");
+    const nodeEnv = resolveNodeEnv(options.nodeEnv);
+    const runtimeConfig = toRuntimeConfig(config, options.configOverride);
+    const enabled = enableLunaRuntimeIntercept(runtimeConfig, nodeEnv);
+    if (!enabled) {
+        return {
+            enabled: false,
+            config,
+        };
+    }
+    const routeMocks = options.configOverride?.intercept?.routes ?? config.intercept?.routes ?? [];
+    setRouteMocks(routeMocks);
+    if (config.given) {
+        applyInterceptState(config.given);
+    }
+    if (config.intercept?.state) {
+        applyInterceptState(config.intercept.state);
+    }
+    const unmountDevtools = options.mountDevtools === false
+        ? undefined
+        : mountLunaDevtools({
+            targetId: options.devtoolsTargetId,
+            nodeEnv,
+        }) ?? undefined;
+    return {
+        enabled: true,
+        unmountDevtools,
+        config,
+    };
+}

package/dist/devtools/LunaDevtoolsPanel.d.ts

@@ -0,0 +1,20 @@
+import { type RouteMock } from "@lunatest/runtime-intercept";
+type LunaDevtoolsPanelProps = {
+    title?: string;
+    initialLua?: string;
+    initialRoutes?: RouteMock[];
+    initialState?: Record<string, unknown>;
+    onRunScenario?: (luaScript: string) => Promise<{
+        pass: boolean;
+        error?: string;
+        diff?: string;
+    }> | {
+        pass: boolean;
+        error?: string;
+        diff?: string;
+    };
+    onSetRouteMocks?: (routes: RouteMock[]) => void | Promise<void>;
+    onPatchState?: (patch: Record<string, unknown>) => void | Promise<void>;
+};
+export declare function LunaDevtoolsPanel(props: LunaDevtoolsPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/devtools/LunaDevtoolsPanel.js

@@ -0,0 +1,148 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { executeLuaScenario, loadLunaConfig } from "@lunatest/core";
+import { applyInterceptState, getInterceptState, setRouteMocks, } from "@lunatest/runtime-intercept";
+function toPrettyJson(input) {
+    return JSON.stringify(input, null, 2);
+}
+export function LunaDevtoolsPanel(props) {
+    const initialLuaScript = useMemo(() => props.initialLua ??
+        `scenario {
+  name = "swap-warning",
+  mode = "strict",
+  given = {
+    pool = { pair = "ETH/USDC", reserve0 = 100, reserve1 = 183000 },
+    wallet = { connected = true, ETH = 10.0 },
+  },
+  when = { action = "swap", input = { tokenIn = "ETH", amount = 50.0 } },
+  then_ui = { slippage_warning = true, severity = "high", button_disabled = true },
+}`, [props.initialLua]);
+    const defaultRoutes = useMemo(() => props.initialRoutes ?? [
+        {
+            endpointType: "ethereum",
+            method: "eth_chainId",
+            responseKey: "chain-id",
+        },
+    ], [props.initialRoutes]);
+    const defaultState = useMemo(() => props.initialState ?? {
+        chain: { id: 1, gasPrice: 30 },
+    }, [props.initialState]);
+    const [luaScript, setLuaScript] = useState(initialLuaScript);
+    const [routeJson, setRouteJson] = useState(toPrettyJson(defaultRoutes));
+    const [stateJson, setStateJson] = useState(toPrettyJson(defaultState));
+    const [status, setStatus] = useState("idle");
+    const [error, setError] = useState(null);
+    const [diff, setDiff] = useState(null);
+    const handleRun = async () => {
+        setError(null);
+        setDiff(null);
+        setStatus("running");
+        try {
+            const executed = props.onRunScenario
+                ? await props.onRunScenario(luaScript)
+                : await (async () => {
+                    const config = await loadLunaConfig(luaScript);
+                    const result = await executeLuaScenario({
+                        source: config,
+                        adapter: {
+                            runWhen: async ({ config: nextConfig, runtime }) => {
+                                if (nextConfig.intercept?.routes) {
+                                    runtime.setRouteMocks(nextConfig.intercept.routes);
+                                    setRouteMocks(nextConfig.intercept.routes);
+                                }
+                                if (nextConfig.given) {
+                                    runtime.applyInterceptState(nextConfig.given);
+                                    applyInterceptState(nextConfig.given);
+                                }
+                                if (nextConfig.intercept?.state) {
+                                    runtime.applyInterceptState(nextConfig.intercept.state);
+                                    applyInterceptState(nextConfig.intercept.state);
+                                }
+                            },
+                            resolveUi: async () => getInterceptState(),
+                            resolveState: async () => getInterceptState(),
+                        },
+                    });
+                    return {
+                        pass: result.pass,
+                        error: result.error,
+                        diff: result.result?.diff,
+                    };
+                })();
+            setStatus(executed.pass ? "pass" : "fail");
+            if (executed.error) {
+                setError(executed.error);
+            }
+            if (executed.diff) {
+                setDiff(executed.diff);
+            }
+        }
+        catch (cause) {
+            setStatus("failed");
+            setError(cause instanceof Error ? cause.message : String(cause));
+        }
+    };
+    const handleApplyRoutes = async () => {
+        setError(null);
+        setDiff(null);
+        setStatus("updating-routes");
+        try {
+            const parsed = JSON.parse(routeJson);
+            if (props.onSetRouteMocks) {
+                await props.onSetRouteMocks(parsed);
+            }
+            else {
+                setRouteMocks(parsed);
+            }
+            setStatus("routes-updated");
+        }
+        catch (cause) {
+            setStatus("failed");
+            setError(cause instanceof Error ? cause.message : String(cause));
+        }
+    };
+    const handlePatchState = async () => {
+        setError(null);
+        setDiff(null);
+        setStatus("patching-state");
+        try {
+            const parsed = JSON.parse(stateJson);
+            if (props.onPatchState) {
+                await props.onPatchState(parsed);
+            }
+            else {
+                applyInterceptState(parsed);
+            }
+            setStatus("state-patched");
+        }
+        catch (cause) {
+            setStatus("failed");
+            setError(cause instanceof Error ? cause.message : String(cause));
+        }
+    };
+    const handleReset = () => {
+        setLuaScript(initialLuaScript);
+        setRouteJson(toPrettyJson(defaultRoutes));
+        setStateJson(toPrettyJson(defaultState));
+        setStatus("reset");
+        setError(null);
+        setDiff(null);
+    };
+    return (_jsxs("aside", { "data-lunatest-devtools": true, style: {
+            position: "fixed",
+            right: 16,
+            bottom: 16,
+            width: 380,
+            maxHeight: "80vh",
+            overflow: "auto",
+            zIndex: 99999,
+            border: "1px solid #cbd5e1",
+            borderRadius: 12,
+            background: "#ffffff",
+            boxShadow: "0 12px 30px rgba(15, 23, 42, 0.18)",
+            fontFamily: "monospace",
+            fontSize: 12,
+            color: "#0f172a",
+            padding: 12,
+        }, children: [_jsx("h3", { style: { margin: 0, marginBottom: 8 }, children: props.title ?? "LunaTest Devtools" }), _jsx("p", { style: { margin: 0, marginBottom: 10, color: "#334155" }, children: "Lua DSL\uACFC \uC778\uD130\uC149\uD2B8 \uC0C1\uD0DC\uB97C \uBE0C\uB77C\uC6B0\uC800\uC5D0\uC11C \uBC14\uB85C \uC218\uC815\uD569\uB2C8\uB2E4." }), _jsx("label", { htmlFor: "lunatest-lua-script", children: "Lua Scenario" }), _jsx("textarea", { id: "lunatest-lua-script", value: luaScript, onChange: (event) => setLuaScript(event.currentTarget.value), style: { width: "100%", minHeight: 140, marginBottom: 8 } }), _jsx("button", { type: "button", onClick: handleRun, children: "Run Scenario" }), _jsx("hr", {}), _jsx("label", { htmlFor: "lunatest-routes", children: "Route Mocks (JSON array)" }), _jsx("textarea", { id: "lunatest-routes", value: routeJson, onChange: (event) => setRouteJson(event.currentTarget.value), style: { width: "100%", minHeight: 110, marginBottom: 8 } }), _jsx("button", { type: "button", onClick: handleApplyRoutes, children: "Apply Routes" }), _jsx("hr", {}), _jsx("label", { htmlFor: "lunatest-state", children: "Intercept State Patch (JSON object)" }), _jsx("textarea", { id: "lunatest-state", value: stateJson, onChange: (event) => setStateJson(event.currentTarget.value), style: { width: "100%", minHeight: 110, marginBottom: 8 } }), _jsx("button", { type: "button", onClick: handlePatchState, children: "Patch State" }), _jsx("button", { type: "button", onClick: handleReset, style: { marginLeft: 8 }, children: "Reset" }), _jsxs("p", { style: { marginTop: 10, marginBottom: 0 }, children: ["status: ", status] }), error ? (_jsxs("p", { style: { marginTop: 4, marginBottom: 0, color: "#b91c1c" }, children: ["error: ", error] })) : null, diff ? (_jsxs("pre", { style: { marginTop: 8, marginBottom: 0, color: "#7f1d1d", whiteSpace: "pre-wrap" }, children: ["diff: ", diff] })) : null] }));
+}

package/dist/devtools/mount.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { LunaDevtoolsPanel } from "./LunaDevtoolsPanel.js";
+export type MountLunaDevtoolsOptions = {
+    targetId?: string;
+    nodeEnv?: string;
+    panelProps?: React.ComponentProps<typeof LunaDevtoolsPanel>;
+};
+export declare function mountLunaDevtools(options?: MountLunaDevtoolsOptions): (() => void) | null;

package/dist/devtools/mount.js

@@ -0,0 +1,41 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import { LunaDevtoolsPanel } from "./LunaDevtoolsPanel.js";
+import { resolveNodeEnv } from "../node-env.js";
+const DEFAULT_TARGET_ID = "lunatest-devtools-root";
+let activeRoot = null;
+let activeTarget = null;
+export function mountLunaDevtools(options = {}) {
+    if (typeof document === "undefined") {
+        return null;
+    }
+    const nodeEnv = resolveNodeEnv(options.nodeEnv);
+    if (nodeEnv !== "development") {
+        return null;
+    }
+    const targetId = options.targetId ?? DEFAULT_TARGET_ID;
+    const existing = document.getElementById(targetId);
+    const target = existing ?? document.createElement("div");
+    if (!existing) {
+        target.id = targetId;
+        document.body.appendChild(target);
+    }
+    if (activeRoot) {
+        activeRoot.unmount();
+        activeRoot = null;
+    }
+    activeRoot = createRoot(target);
+    activeTarget = target;
+    activeRoot.render(React.createElement(LunaDevtoolsPanel, options.panelProps));
+    return () => {
+        if (!activeRoot || !activeTarget) {
+            return;
+        }
+        activeRoot.unmount();
+        if (activeTarget.id === DEFAULT_TARGET_ID) {
+            activeTarget.remove();
+        }
+        activeRoot = null;
+        activeTarget = null;
+    };
+}

package/dist/hooks/useLunaProvider.d.ts

@@ -0,0 +1,2 @@
+import { type LunaProviderOptions } from "@lunatest/core";
+export declare function useLunaProvider(options: LunaProviderOptions): import("@lunatest/core").LunaProvider;

package/dist/hooks/useLunaProvider.js

@@ -0,0 +1,5 @@
+import { useMemo } from "react";
+import { createLunaProvider } from "../luna-provider.js";
+export function useLunaProvider(options) {
+    return useMemo(() => createLunaProvider(options), [options]);
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { createLunaProvider } from "./luna-provider.js";
+export { LunaTestProvider } from "./LunaTestProvider.js";
+export { useLunaProvider } from "./hooks/useLunaProvider.js";
+export { useLunaTest } from "./useLunaTest.js";
+export { withLunaWagmiConfig } from "./adapters/wagmi.js";
+export { createEthersAdapter } from "./adapters/ethers.js";
+export { createWeb3JsAdapter } from "./adapters/web3js.js";
+export { enableLunaIntercept } from "./intercept.js";
+export type { LunaBootstrapOptions, LunaBootstrapResult } from "./bootstrap.js";
+export { bootstrapLunaRuntime } from "./bootstrap.js";
+export { LunaDevtoolsPanel } from "./devtools/LunaDevtoolsPanel.js";
+export { mountLunaDevtools } from "./devtools/mount.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { createLunaProvider } from "./luna-provider.js";
+export { LunaTestProvider } from "./LunaTestProvider.js";
+export { useLunaProvider } from "./hooks/useLunaProvider.js";
+export { useLunaTest } from "./useLunaTest.js";
+export { withLunaWagmiConfig } from "./adapters/wagmi.js";
+export { createEthersAdapter } from "./adapters/ethers.js";
+export { createWeb3JsAdapter } from "./adapters/web3js.js";
+export { enableLunaIntercept } from "./intercept.js";
+export { bootstrapLunaRuntime } from "./bootstrap.js";
+export { LunaDevtoolsPanel } from "./devtools/LunaDevtoolsPanel.js";
+export { mountLunaDevtools } from "./devtools/mount.js";

package/dist/intercept.d.ts

@@ -0,0 +1,6 @@
+import { type LunaRuntimeInterceptConfig } from "@lunatest/runtime-intercept";
+export type EnableLunaInterceptOptions = {
+    config?: LunaRuntimeInterceptConfig;
+    nodeEnv?: string;
+};
+export declare function enableLunaIntercept(options?: EnableLunaInterceptOptions): boolean;

package/dist/intercept.js

@@ -0,0 +1,6 @@
+import { enableLunaRuntimeIntercept, } from "@lunatest/runtime-intercept";
+import { resolveNodeEnv } from "./node-env.js";
+export function enableLunaIntercept(options = {}) {
+    const nodeEnv = resolveNodeEnv(options.nodeEnv);
+    return enableLunaRuntimeIntercept(options.config ?? {}, nodeEnv);
+}

package/dist/luna-provider.d.ts

@@ -0,0 +1,2 @@
+import { LunaProvider, type LunaProviderOptions } from "@lunatest/core";
+export declare function createLunaProvider(options: LunaProviderOptions): LunaProvider;

package/dist/luna-provider.js

@@ -0,0 +1,4 @@
+import { LunaProvider } from "@lunatest/core";
+export function createLunaProvider(options) {
+    return new LunaProvider(options);
+}

package/dist/node-env.d.ts

@@ -0,0 +1 @@
+export declare function resolveNodeEnv(explicit?: string): string | undefined;

package/dist/node-env.js

@@ -0,0 +1,13 @@
+export function resolveNodeEnv(explicit) {
+    if (explicit) {
+        return explicit;
+    }
+    const modeFromImportMeta = import.meta?.env?.MODE;
+    if (typeof modeFromImportMeta === "string" && modeFromImportMeta.length > 0) {
+        return modeFromImportMeta;
+    }
+    if (typeof process !== "undefined") {
+        return process.env.NODE_ENV;
+    }
+    return undefined;
+}

package/dist/useLunaTest.d.ts

@@ -0,0 +1 @@
+export declare function useLunaTest(): import("./LunaTestProvider.js").LunaTestContextValue;

package/dist/useLunaTest.js

@@ -0,0 +1,9 @@
+import { useContext } from "react";
+import { LunaTestContext } from "./LunaTestProvider.js";
+export function useLunaTest() {
+    const context = useContext(LunaTestContext);
+    if (!context) {
+        throw new Error("useLunaTest must be used within LunaTestProvider");
+    }
+    return context;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@lunatest/react",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@lunatest/core": "0.1.0",
+    "@lunatest/runtime-intercept": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": "^18.3.1 || ^19.0.0",
+    "react-dom": "^18.3.1 || ^19.0.0"
+  },
+  "devDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  }
+}