atmx-react 0.44.0 → 0.48.0

package/dist/index.js

@@ -0,0 +1,628 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AxQuery: () => AxQuery,
+  AxTrigger: () => AxTrigger,
+  AxWhen: () => AxWhen,
+  AxiomContext: () => AxiomContext,
+  AxiomDataContext: () => AxiomDataContext,
+  AxiomProvider: () => AxiomProvider,
+  axiomQueryManager: () => axiomQueryManager,
+  clearAuthToken: () => import_atmx_web.clearAuthToken,
+  setAuthToken: () => import_atmx_web.setAuthToken,
+  useAxiom: () => useAxiom,
+  useAxiomContext: () => useAxiomContext,
+  useAxiomData: () => useAxiomData,
+  useAxiomMutation: () => useAxiomMutation,
+  useAxiomQuery: () => useAxiomQuery
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/core-bridge.ts
+var import_atmx_web = require("atmx-web");
+var import_atmx_web2 = require("atmx-web");
+var import_atmx_web3 = require("atmx-web");
+var globalReqCounter = 0;
+var getNextReqId = () => ++globalReqCounter;
+
+// src/context/AxiomProvider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var AxiomContext = (0, import_react.createContext)(
+  void 0
+);
+var AxiomProvider = ({
+  configUrl,
+  config,
+  children,
+  fallback
+}) => {
+  const [state, setState] = (0, import_react.useState)({
+    isReady: false,
+    error: null,
+    config: null
+  });
+  const initStarted = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    if (initStarted.current) return;
+    initStarted.current = true;
+    const bootSequence = async () => {
+      try {
+        let finalConfig;
+        if (configUrl) {
+          const res = await fetch(configUrl);
+          if (!res.ok)
+            throw new Error(`Failed to load config from ${configUrl}`);
+          finalConfig = await res.json();
+        } else if (config) {
+          finalConfig = config;
+        } else {
+          throw new Error(
+            "AxiomProvider requires either 'configUrl' or 'config' prop."
+          );
+        }
+        if (!finalConfig.contracts || Object.keys(finalConfig.contracts).length === 0) {
+          throw new Error("No contracts defined in ATMX config.");
+        }
+        await (0, import_atmx_web.initWasm)(finalConfig);
+        console.log(`\u269B\uFE0F ATMX-React: Provider ready.`);
+        setState({ isReady: true, error: null, config: finalConfig });
+      } catch (err) {
+        console.error("ATMX Provider Boot Error:", err);
+        setState({ isReady: false, error: err, config: null });
+      }
+    };
+    bootSequence();
+  }, [configUrl, config]);
+  if (state.error)
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { color: "red", padding: "20px", fontFamily: "monospace" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: "ATMX Initialization Failed:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("br", {}),
+      state.error.message
+    ] });
+  if (!state.isReady) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: fallback || null });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AxiomContext.Provider, { value: state, children });
+};
+
+// src/context/AxiomDataContext.tsx
+var import_react2 = require("react");
+var AxiomDataContext = (0, import_react2.createContext)(null);
+function useAxiomContext() {
+  const context = (0, import_react2.useContext)(AxiomDataContext);
+  if (!context) {
+    throw new Error(
+      "useAxiomContext must be used within an <AxQuery> or <AxMutate> scope."
+    );
+  }
+  return context;
+}
+function useAxiomData() {
+  const context = (0, import_react2.useContext)(AxiomDataContext);
+  return context?.data || {};
+}
+
+// src/hooks/useAxiomQuery.ts
+var import_react4 = require("react");
+
+// src/hooks/useAxiom.ts
+var import_react3 = require("react");
+var useAxiom = () => {
+  const context = (0, import_react3.useContext)(AxiomContext);
+  if (context === void 0) {
+    throw new Error("useAxiom must be used within an <AxiomProvider>. Did you forget to wrap your app?");
+  }
+  return context;
+};
+
+// src/core/ActiveQuery.ts
+var ActiveQuery = class {
+  constructor(queryKey, def) {
+    __publicField(this, "queryKey");
+    __publicField(this, "def");
+    __publicField(this, "state");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "currentReqId", null);
+    this.queryKey = queryKey;
+    this.def = def;
+    this.state = {
+      status: "idle",
+      data: null,
+      error: null,
+      isFetching: false,
+      isMutating: false,
+      source: null
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  updateState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.listeners.forEach((l) => l(this.state));
+  }
+  fetch(force = false, debug = false) {
+    if (this.state.isFetching && !force) return;
+    this.updateState({
+      isFetching: true,
+      status: this.state.data ? "success" : "loading"
+    });
+    const reqId = getNextReqId();
+    this.currentReqId = reqId;
+    const syntheticRoute = {
+      id: this.def.endpointId,
+      namespace: this.def.namespace,
+      name: this.def.name || "unknown",
+      method: this.def.method,
+      pathTemplate: this.def.path,
+      isStream: !!this.def.isStream
+    };
+    const { path } = (0, import_atmx_web2.buildRequestPath)(syntheticRoute, this.def.args);
+    if (debug) {
+      console.groupCollapsed(
+        `%c\u2794 WASM QUERY [#${reqId}]`,
+        `color: #7c3aed; font-weight: bold;`
+      );
+      console.log("Namespace:", this.def.namespace);
+      console.log("Endpoint ID:", this.def.endpointId);
+      console.log("Path:", path);
+      console.groupEnd();
+    }
+    import_atmx_web3.pendingRequests.set(reqId, {
+      isStream: !!this.def.isStream,
+      onResponse: (response) => {
+        if (this.currentReqId !== reqId) return;
+        if (debug) {
+          const evtName = response.eventType === 1 ? "NetworkSuccess" : response.eventType === 2 ? "CacheHit" : response.eventType === 3 ? "CacheHitAndFetching" : response.eventType === 4 ? "Error" : "Complete";
+          console.groupCollapsed(
+            `%c\u2190 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) {
+          this.updateState({
+            status: "error",
+            error: response.error || null,
+            isFetching: false
+          });
+          return;
+        }
+        if (response.data) {
+          try {
+            const decodedData = this.def.decoder(response.data);
+            let source = "network";
+            let isFetching = false;
+            if (response.eventType === 2) {
+              source = "cache";
+              isFetching = false;
+            } else if (response.eventType === 3) {
+              source = "cache";
+              isFetching = true;
+            } else if (response.eventType === 1) {
+              source = "network";
+              isFetching = false;
+            }
+            this.updateState({
+              status: "success",
+              data: decodedData,
+              error: null,
+              isFetching,
+              source
+            });
+          } catch (e) {
+            this.updateState({
+              status: "error",
+              error: { message: "Decoding failed", details: String(e) },
+              isFetching: false
+            });
+          }
+        }
+      },
+      onComplete: () => {
+        if (this.currentReqId !== reqId) return;
+        this.updateState({ isFetching: false });
+      }
+    });
+    const isFormUrlEncoded = Object.entries(this.def.headers || {}).some(
+      ([k, v]) => k.toLowerCase() === "content-type" && v.includes("application/x-www-form-urlencoded")
+    );
+    let payloadPtr = 0, payloadLen = 0;
+    if (this.def.payload !== void 0 && this.def.payload !== null) {
+      const safePayload = this.def.serializer ? this.def.serializer(this.def.payload) : this.def.payload;
+      let payloadBytes;
+      if (isFormUrlEncoded && typeof safePayload === "object") {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(safePayload))
+          params.append(k, String(v));
+        payloadBytes = new TextEncoder().encode(params.toString());
+      } else {
+        payloadBytes = new TextEncoder().encode(JSON.stringify(safePayload));
+      }
+      payloadPtr = (0, import_atmx_web.allocBytes)(payloadBytes);
+      payloadLen = payloadBytes.length;
+    }
+    const nsStr = (0, import_atmx_web.allocString)(this.def.namespace);
+    const mStr = (0, import_atmx_web.allocString)(this.def.method);
+    const pStr = (0, import_atmx_web.allocString)(path);
+    const tpStr = (0, import_atmx_web.allocString)("");
+    const hStr = (0, import_atmx_web.allocString)(
+      this.def.headers ? JSON.stringify(this.def.headers) : ""
+    );
+    import_atmx_web.wasmEngine.axiom_wasm_call(
+      reqId,
+      nsStr.ptr,
+      nsStr.len,
+      this.def.endpointId,
+      mStr.ptr,
+      mStr.len,
+      pStr.ptr,
+      pStr.len,
+      tpStr.ptr,
+      tpStr.len,
+      hStr.ptr,
+      hStr.len,
+      payloadPtr,
+      payloadLen
+    );
+    import_atmx_web.wasmEngine.axiom_free_memory(nsStr.ptr, nsStr.len);
+    import_atmx_web.wasmEngine.axiom_free_memory(mStr.ptr, mStr.len);
+    import_atmx_web.wasmEngine.axiom_free_memory(pStr.ptr, pStr.len);
+    import_atmx_web.wasmEngine.axiom_free_memory(tpStr.ptr, tpStr.len);
+    import_atmx_web.wasmEngine.axiom_free_memory(hStr.ptr, hStr.len);
+  }
+};
+
+// src/core/QueryManager.ts
+var QueryManager = class {
+  constructor() {
+    __publicField(this, "queries", /* @__PURE__ */ new Map());
+  }
+  buildKey(namespace, endpointId, args) {
+    return `${namespace}:${endpointId}:${JSON.stringify(args)}`;
+  }
+  getQuery(def) {
+    const key = this.buildKey(def.namespace, def.endpointId, def.args);
+    if (this.queries.has(key)) {
+      return this.queries.get(key);
+    }
+    const newQuery = new ActiveQuery(key, def);
+    this.queries.set(key, newQuery);
+    return newQuery;
+  }
+  invalidate(namespace, endpointId, args) {
+    const key = this.buildKey(namespace, endpointId, args);
+    const query = this.queries.get(key);
+    if (query) query.fetch(true);
+  }
+};
+var axiomQueryManager = new QueryManager();
+
+// src/hooks/useAxiomQuery.ts
+function useAxiomQuery(queryDef, options = {}) {
+  const { isReady, config } = useAxiom();
+  const { enabled = true } = options;
+  const activeQuery = axiomQueryManager.getQuery(queryDef);
+  const state = (0, import_react4.useSyncExternalStore)(
+    (0, import_react4.useCallback)(
+      (onStoreChange) => activeQuery.subscribe(onStoreChange),
+      [activeQuery]
+    ),
+    () => activeQuery.getState(),
+    () => activeQuery.getState()
+  );
+  (0, import_react4.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,
+    // Export raw state for <AxWhen>
+    refetch: () => activeQuery.fetch(true, config?.debug)
+  };
+}
+
+// src/components/AxQuery.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function AxQuery({
+  call,
+  children,
+  enabled = true
+}) {
+  const result = useAxiomQuery(call, { enabled });
+  const content = typeof children === "function" ? children({
+    data: result.data,
+    state: result.state,
+    refetch: result.refetch
+  }) : children;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AxiomDataContext.Provider, { value: result.state, children: content });
+}
+
+// src/components/AxWhen.tsx
+var import_react5 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function AxWhen({ value, is, children }) {
+  const context = (0, import_react5.useContext)(AxiomDataContext);
+  const stateObj = value || context;
+  if (!stateObj) return null;
+  const expectedStates = is.split(",").map((s) => s.trim().toLowerCase());
+  let currentState = "idle";
+  if (stateObj.isMutating) {
+    currentState = "mutating";
+  } else if (stateObj.status === "loading") {
+    currentState = "loading";
+  } else if (stateObj.status === "error") {
+    currentState = "error";
+  } else if (stateObj.status === "success" || stateObj.data) {
+    currentState = "data";
+  }
+  if (expectedStates.includes("success") && stateObj.status === "success" && !stateObj.isMutating) {
+    currentState = "success";
+  }
+  if (expectedStates.includes(currentState)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children });
+  }
+  return null;
+}
+
+// src/components/AxTrigger.tsx
+var import_react6 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var AxTrigger = ({ onTrigger, once = true, children }) => {
+  const elementRef = (0, import_react6.useRef)(null);
+  const hasTriggered = (0, import_react6.useRef)(false);
+  (0, import_react6.useEffect)(() => {
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          if (once && hasTriggered.current) return;
+          onTrigger();
+          hasTriggered.current = true;
+          if (once) observer.unobserve(entry.target);
+        }
+      });
+    }, { threshold: 0.1 });
+    if (elementRef.current) {
+      observer.observe(elementRef.current);
+    }
+    return () => observer.disconnect();
+  }, [onTrigger, once]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { ref: elementRef, children });
+};
+
+// src/hooks/useAxiomMutation.ts
+var import_react7 = require("react");
+function extractFieldError(error, fieldName) {
+  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;
+}
+function useAxiomMutation(mutationFn) {
+  const { isReady, config } = useAxiom();
+  const [state, setState] = (0, import_react7.useState)({
+    status: "idle",
+    data: null,
+    error: null,
+    isFetching: false,
+    isMutating: false,
+    source: null
+  });
+  const isMounted = (0, import_react7.useRef)(true);
+  (0, import_react7.useEffect)(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  const execute = (0, import_react7.useCallback)(
+    async (args, options) => {
+      if (!isReady || !config) return;
+      const rawDef = mutationFn(args);
+      rawDef.headers = options?.headers;
+      const reqId = getNextReqId();
+      if (isMounted.current)
+        setState({
+          status: "loading",
+          data: null,
+          error: null,
+          isFetching: false,
+          isMutating: true,
+          source: null
+        });
+      const syntheticRoute = {
+        id: rawDef.endpointId,
+        namespace: rawDef.namespace,
+        name: rawDef.name || "unknown",
+        method: rawDef.method,
+        pathTemplate: rawDef.path,
+        isStream: !!rawDef.isStream
+      };
+      const { path } = (0, import_atmx_web2.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 !== void 0 && rawDef.payload !== null) {
+        payloadObj = rawDef.serializer ? rawDef.serializer(rawDef.payload) : rawDef.payload;
+        let payloadBytes;
+        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 = (0, import_atmx_web.allocBytes)(payloadBytes);
+        payloadLen = payloadBytes.length;
+      }
+      if (config.debug) {
+        console.groupCollapsed(
+          `%c\u2794 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();
+      }
+      import_atmx_web3.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\u2190 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 = "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)
+                },
+                isFetching: false,
+                isMutating: false,
+                data: null,
+                source: null
+              });
+            }
+          }
+        },
+        onComplete: () => {
+          if (isMounted.current)
+            setState((prev) => ({
+              ...prev,
+              isMutating: false,
+              isFetching: false
+            }));
+        }
+      });
+      const nsStr = (0, import_atmx_web.allocString)(rawDef.namespace);
+      const mStr = (0, import_atmx_web.allocString)(rawDef.method);
+      const pStr = (0, import_atmx_web.allocString)(path);
+      const tpStr = (0, import_atmx_web.allocString)("");
+      const hStr = (0, import_atmx_web.allocString)(
+        rawDef.headers ? JSON.stringify(rawDef.headers) : ""
+      );
+      import_atmx_web.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
+      );
+      import_atmx_web.wasmEngine.axiom_free_memory(nsStr.ptr, nsStr.len);
+      import_atmx_web.wasmEngine.axiom_free_memory(mStr.ptr, mStr.len);
+      import_atmx_web.wasmEngine.axiom_free_memory(pStr.ptr, pStr.len);
+      import_atmx_web.wasmEngine.axiom_free_memory(tpStr.ptr, tpStr.len);
+      import_atmx_web.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) => extractFieldError(state.error, fieldName)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AxQuery,
+  AxTrigger,
+  AxWhen,
+  AxiomContext,
+  AxiomDataContext,
+  AxiomProvider,
+  axiomQueryManager,
+  clearAuthToken,
+  setAuthToken,
+  useAxiom,
+  useAxiomContext,
+  useAxiomData,
+  useAxiomMutation,
+  useAxiomQuery
+});
+//# sourceMappingURL=index.js.map