atmx-react 0.43.0 → 0.47.0

package/src/hooks/useAxiomMutation.ts

@@ -1,236 +0,0 @@
-// FILE: src/hooks/useAxiomMutation.ts
-import { useState, useCallback, useRef, useEffect } from "react";
-import { useAxiom } from "./useAxiom";
-import {
-  AxiomQueryDef,
-  AxiomState,
-  getNextReqId,
-  wasmEngine,
-  allocString,
-  allocBytes,
-  pendingRequests,
-  buildRequestPath,
-  Route,
-} from "../utils/core-bridge";
-
-function extractFieldError(error: any, fieldName: string): string | null {
-  if (error?.code !== "ValidationError" || !error?.details) return null;
-  const lines = error.details.split("\n");
-  for (const line of lines) {
-    if (line.startsWith(fieldName + ":"))
-      return line.substring(fieldName.length + 1).trim();
-  }
-  return null;
-}
-
-export function useAxiomMutation<T, A>(
-  mutationFn: (args: A) => AxiomQueryDef<T>,
-) {
-  const { isReady, config } = useAxiom();
-  const [state, setState] = useState<AxiomState<T>>({
-    status: "idle",
-    data: null,
-    error: null,
-    isFetching: false,
-    isMutating: false,
-    source: null,
-  });
-  const isMounted = useRef(true);
-
-  useEffect(() => {
-    isMounted.current = true;
-    return () => {
-      isMounted.current = false;
-    };
-  }, []);
-
-  const execute = useCallback(
-    async (args: A, options?: { headers?: Record<string, string> }) => {
-      if (!isReady || !config) return;
-
-      const rawDef = mutationFn(args);
-      rawDef.headers = options?.headers; // ✨ Inject dynamic headers!
-
-      const reqId = getNextReqId();
-      if (isMounted.current)
-        setState({
-          status: "loading",
-          data: null,
-          error: null,
-          isFetching: false,
-          isMutating: true,
-          source: null,
-        });
-
-      // FIX: Bypass router lookup!
-      const syntheticRoute: Route = {
-        id: rawDef.endpointId,
-        namespace: rawDef.namespace,
-        name: rawDef.name || "unknown",
-        method: rawDef.method,
-        pathTemplate: rawDef.path,
-        isStream: !!rawDef.isStream,
-      };
-
-      const { path } = buildRequestPath(syntheticRoute, rawDef.args);
-
-      const isFormUrlEncoded = Object.entries(rawDef.headers || {}).some(
-        ([k, v]) =>
-          k.toLowerCase() === "content-type" &&
-          v.includes("application/x-www-form-urlencoded"),
-      );
-
-      let payloadPtr = 0,
-        payloadLen = 0,
-        payloadObj = null;
-      if (rawDef.payload !== undefined && rawDef.payload !== null) {
-        payloadObj = rawDef.serializer
-          ? rawDef.serializer(rawDef.payload)
-          : rawDef.payload;
-        let payloadBytes: Uint8Array;
-
-        if (isFormUrlEncoded && typeof payloadObj === "object") {
-          const params = new URLSearchParams();
-          for (const [k, v] of Object.entries(payloadObj))
-            params.append(k, String(v));
-          payloadBytes = new TextEncoder().encode(params.toString());
-        } else {
-          payloadBytes = new TextEncoder().encode(JSON.stringify(payloadObj));
-        }
-
-        payloadPtr = allocBytes(payloadBytes);
-        payloadLen = payloadBytes.length;
-      }
-
-      if (config.debug) {
-        console.groupCollapsed(
-          `%c➔ WASM MUTATE [#${reqId}]`,
-          `color: #7c3aed; font-weight: bold;`,
-        );
-        console.log("Namespace:", rawDef.namespace);
-        console.log("Endpoint ID:", rawDef.endpointId);
-        console.log("Path:", path);
-        console.log("Payload:", payloadObj);
-        console.groupEnd();
-      }
-
-      pendingRequests.set(reqId, {
-        isStream: !!rawDef.isStream,
-        onResponse: (response) => {
-          if (!isMounted.current) return;
-
-          if (config.debug) {
-            const evtName =
-              response.eventType === 1
-                ? "NetworkSuccess"
-                : response.eventType === 2
-                  ? "CacheHit"
-                  : response.eventType === 3
-                    ? "CacheHitAndFetching"
-                    : response.eventType === 4
-                      ? "Error"
-                      : "Complete";
-            console.groupCollapsed(
-              `%c← WASM RESP [#${reqId}]`,
-              `color: #059669; font-weight: bold;`,
-            );
-            console.log("Event Type:", evtName);
-            if (response.data) console.log("Data:", response.data);
-            if (response.error) console.log("Error:", response.error);
-            console.groupEnd();
-          }
-
-          if (response.eventType === 4) {
-            setState({
-              status: "error",
-              error: response.error || null,
-              isFetching: false,
-              isMutating: false,
-              data: null,
-              source: null,
-            });
-            return;
-          }
-          if (response.data) {
-            try {
-              let source: "cache" | "network" = "network";
-              if (response.eventType === 2 || response.eventType === 3)
-                source = "cache";
-
-              setState({
-                status: "success",
-                data: rawDef.decoder(response.data),
-                error: null,
-                isFetching: false,
-                isMutating: false,
-                source,
-              });
-            } catch (e) {
-              setState({
-                status: "error",
-                error: {
-                  message: "Decoding failed",
-                  details: String(e),
-                } as any,
-                isFetching: false,
-                isMutating: false,
-                data: null,
-                source: null,
-              });
-            }
-          }
-        },
-        onComplete: () => {
-          if (isMounted.current)
-            setState((prev) => ({
-              ...prev,
-              isMutating: false,
-              isFetching: false,
-            }));
-        },
-      });
-
-      const nsStr = allocString(rawDef.namespace);
-      const mStr = allocString(rawDef.method);
-      const pStr = allocString(path);
-      const tpStr = allocString("");
-      const hStr = allocString(
-        rawDef.headers ? JSON.stringify(rawDef.headers) : "",
-      );
-
-      wasmEngine.axiom_wasm_call(
-        reqId,
-        nsStr.ptr,
-        nsStr.len,
-        rawDef.endpointId,
-        mStr.ptr,
-        mStr.len,
-        pStr.ptr,
-        pStr.len,
-        tpStr.ptr,
-        tpStr.len,
-        hStr.ptr,
-        hStr.len,
-        payloadPtr,
-        payloadLen,
-      );
-
-      wasmEngine.axiom_free_memory(nsStr.ptr, nsStr.len);
-      wasmEngine.axiom_free_memory(mStr.ptr, mStr.len);
-      wasmEngine.axiom_free_memory(pStr.ptr, pStr.len);
-      wasmEngine.axiom_free_memory(tpStr.ptr, tpStr.len);
-      wasmEngine.axiom_free_memory(hStr.ptr, hStr.len);
-    },
-    [isReady, config, mutationFn],
-  );
-
-  return {
-    execute,
-    state,
-    data: state.data,
-    isMutating: state.isMutating,
-    error: state.error,
-    getFieldError: (fieldName: string) =>
-      extractFieldError(state.error, fieldName),
-  };
-}

package/src/hooks/useAxiomQuery.ts

@@ -1,41 +0,0 @@
-// FILE: src/hooks/useAxiomQuery.ts
-import { useEffect, useSyncExternalStore, useCallback } from "react";
-import { useAxiom } from "./useAxiom";
-import { AxiomQueryDef } from "../utils/core-bridge";
-import { axiomQueryManager } from "../core/QueryManager";
-
-export function useAxiomQuery<T>(
-  queryDef: AxiomQueryDef<T>,
-  options: { enabled?: boolean } = {},
-) {
-  const { isReady, config } = useAxiom();
-  const { enabled = true } = options;
-
-  const activeQuery = axiomQueryManager.getQuery(queryDef);
-
-  const state = useSyncExternalStore(
-    useCallback(
-      (onStoreChange) => activeQuery.subscribe(onStoreChange),
-      [activeQuery],
-    ),
-    () => activeQuery.getState(),
-    () => activeQuery.getState(),
-  );
-
-  useEffect(() => {
-    if (!isReady || !enabled) return;
-    if (state.status === "idle") {
-      activeQuery.fetch(false, config?.debug);
-    }
-  }, [isReady, enabled, activeQuery, state.status, config?.debug]);
-
-  return {
-    data: state.data,
-    isLoading: state.status === "loading",
-    isFetching: state.isFetching,
-    source: state.source,
-    error: state.error,
-    state: state, // Export raw state for <AxWhen>
-    refetch: () => activeQuery.fetch(true, config?.debug),
-  };
-}

package/src/index.ts

@@ -1,39 +0,0 @@
-// FILE: src/index.ts
-export { setAuthToken, clearAuthToken } from "./utils/core-bridge";
-// 1. Context & Provider (Global Lifecycle)
-export { AxiomProvider, AxiomContext } from "./context/AxiomProvider";
-
-// 2. The Context Stack (InheritedWidget Pattern)
-// This allows nested components to reach up and grab parent $data
-export {
-  AxiomDataContext,
-  useAxiomContext,
-  useAxiomData,
-} from "./context/AxiomDataContext";
-
-// 3. High-Level Declarative Components
-// These wrap the hooks to give a "Zero-JS" feel to React
-export { AxQuery } from "./components/AxQuery";
-export { AxWhen } from "./components/AxWhen";
-export { AxTrigger } from "./components/AxTrigger";
-
-// 4. Core Hooks
-// Used primarily by the generated SDK, but available for custom logic
-export { useAxiom } from "./hooks/useAxiom";
-export { useAxiomQuery } from "./hooks/useAxiomQuery";
-export { useAxiomMutation } from "./hooks/useAxiomMutation";
-
-// 5. Shared State & Registry
-// Manages deduplication and syncing across components
-export { axiomQueryManager } from "./core/QueryManager";
-
-// 6. Core Types
-// Essential for type-safe development and generated SDKs
-export type {
-  AtmxConfig,
-  AxiomError,
-  AxiomResponse,
-  AxiomQueryDef,
-  AxiomState,
-  AxiomStatus,
-} from "./utils/core-bridge";

package/src/utils/core-bridge.ts

@@ -1,62 +0,0 @@
-import {
-  initWasm,
-  wasmEngine,
-  allocBytes,
-  allocString,
-  setAuthToken,
-  clearAuthToken,
-} from "atmx-web/src/core/wasm";
-import {
-  resolveRoute,
-  Route,
-  buildRequestPath,
-} from "atmx-web/src/core/router";
-import { pendingRequests } from "atmx-web/src/core/callback";
-import {
-  AtmxConfig,
-  AxiomResponse,
-  AxiomError,
-  EventType,
-} from "atmx-web/src/core/types";
-
-let globalReqCounter = 0;
-export const getNextReqId = () => ++globalReqCounter;
-
-export interface AxiomQueryDef<T> {
-  namespace: string;
-  name: string;
-  endpointId: number;
-  method: string;
-  path: string;
-  payload?: any;
-  decoder: (json: any) => T;
-  serializer?: (payload: any) => any;
-  args: Record<string, any>;
-  isStream?: boolean;
-  headers?: Record<string, string>; // ✨ NEW
-}
-
-export type AxiomStatus = "idle" | "loading" | "success" | "error";
-
-export interface AxiomState<T> {
-  status: AxiomStatus;
-  data: T | null;
-  error: AxiomError | null;
-  isFetching: boolean;
-  isMutating: boolean;
-  source: "cache" | "network" | null;
-}
-
-export {
-  initWasm,
-  wasmEngine,
-  allocBytes,
-  allocString,
-  resolveRoute,
-  buildRequestPath,
-  pendingRequests,
-  setAuthToken,
-  clearAuthToken,
-};
-
-export type { AtmxConfig, AxiomResponse, AxiomError, EventType, Route };

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2020",
-        "useDefineForClassFields": true,
-        "lib": [
-            "ES2020",
-            "DOM",
-            "DOM.Iterable"
-        ],
-        "module": "ESNext",
-        "skipLibCheck": true,
-        "moduleResolution": "bundler",
-        "allowImportingTsExtensions": true,
-        "resolveJsonModule": true,
-        "isolatedModules": true,
-        "noEmit": true,
-        "jsx": "react-jsx",
-        "strict": true,
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "noFallthroughCasesInSwitch": true,
-        "declaration": true
-    },
-    "include": [
-        "src"
-    ]
-}

package/tsup.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-    entry: ['src/index.ts'],
-    format: ['cjs', 'esm'],
-    dts: true,
-    splitting: false,
-    sourcemap: true,
-    clean: true,
-    external: ['react', 'react-dom', 'atmx'],
-});