baraqex/dist/browser.js

A powerful full-stack framework for modern web development

// node_modules/frontend-hamroun/dist/index.mjs
var isBatching = false;
var queue = [];
function batchUpdates(fn) {
  if (isBatching) {
    queue.push(fn);
    return;
  }
  isBatching = true;
  try {
    fn();
    while (queue.length > 0) {
      const nextFn = queue.shift();
      nextFn == null ? void 0 : nextFn();
    }
  } finally {
    isBatching = false;
  }
}
var currentRender = 0;
var states = /* @__PURE__ */ new Map();
var stateIndices = /* @__PURE__ */ new Map();
var effects = /* @__PURE__ */ new Map();
var memos = /* @__PURE__ */ new Map();
var refs = /* @__PURE__ */ new Map();
var globalRenderCallback = null;
var globalContainer = null;
var currentElement = null;
var isServer = typeof window === "undefined";
var serverStates = /* @__PURE__ */ new Map();
function setRenderCallback(callback, element, container) {
  globalRenderCallback = callback;
  globalContainer = container;
  currentElement = element;
}
function prepareRender() {
  currentRender++;
  stateIndices.set(currentRender, 0);
  return currentRender;
}
function finishRender() {
  if (isServer) {
    serverStates.delete(currentRender);
  }
  currentRender = 0;
}
function useState(initial) {
  if (!currentRender) {
    throw new Error("useState must be called within a render");
  }
  if (isServer) {
    if (!serverStates.has(currentRender)) {
      serverStates.set(currentRender, /* @__PURE__ */ new Map());
    }
    const componentState = serverStates.get(currentRender);
    const index2 = stateIndices.get(currentRender) || 0;
    if (!componentState.has(index2)) {
      componentState.set(index2, initial);
    }
    const state2 = componentState.get(index2);
    const setState2 = (newValue) => {
    };
    stateIndices.set(currentRender, index2 + 1);
    return [state2, setState2];
  }
  if (!states.has(currentRender)) {
    states.set(currentRender, []);
  }
  const componentStates = states.get(currentRender);
  const index = stateIndices.get(currentRender);
  if (index >= componentStates.length) {
    componentStates.push(initial);
  }
  const state = componentStates[index];
  const setState = (newValue) => {
    const nextValue = typeof newValue === "function" ? newValue(componentStates[index]) : newValue;
    if (componentStates[index] === nextValue)
      return;
    componentStates[index] = nextValue;
    if (isBatching) {
      batchUpdates(() => rerender(currentRender));
    } else {
      rerender(currentRender);
    }
  };
  stateIndices.set(currentRender, index + 1);
  return [state, setState];
}
function useEffect(callback, deps) {
  if (!currentRender)
    throw new Error("useEffect must be called within a render");
  const effectIndex = stateIndices.get(currentRender);
  if (!effects.has(currentRender)) {
    effects.set(currentRender, []);
  }
  const componentEffects = effects.get(currentRender);
  const prevEffect = componentEffects[effectIndex];
  if (!prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => dep !== prevEffect.deps[i])) {
    if (prevEffect == null ? void 0 : prevEffect.cleanup) {
      prevEffect.cleanup();
    }
    queueMicrotask(() => {
      const cleanup = callback() || void 0;
      componentEffects[effectIndex] = { cleanup, deps };
    });
  }
  stateIndices.set(currentRender, effectIndex + 1);
}
function useMemo(factory, deps) {
  if (!currentRender)
    throw new Error("useMemo must be called within a render");
  const memoIndex = stateIndices.get(currentRender);
  if (!memos.has(currentRender)) {
    memos.set(currentRender, []);
  }
  const componentMemos = memos.get(currentRender);
  const prevMemo = componentMemos[memoIndex];
  if (!prevMemo || deps && deps.some((dep, i) => !Object.is(dep, prevMemo.deps[i]))) {
    const value = factory();
    componentMemos[memoIndex] = { value, deps };
    stateIndices.set(currentRender, memoIndex + 1);
    return value;
  }
  stateIndices.set(currentRender, memoIndex + 1);
  return prevMemo.value;
}
function useRef(initial) {
  if (!currentRender)
    throw new Error("useRef must be called within a render");
  const refIndex = stateIndices.get(currentRender);
  if (!refs.has(currentRender)) {
    refs.set(currentRender, []);
  }
  const componentRefs = refs.get(currentRender);
  if (refIndex >= componentRefs.length) {
    const ref2 = { current: initial };
    componentRefs.push(ref2);
    stateIndices.set(currentRender, refIndex + 1);
    return ref2;
  }
  const ref = componentRefs[refIndex];
  stateIndices.set(currentRender, refIndex + 1);
  return ref;
}
async function rerender(rendererId) {
  try {
    const componentEffects = effects.get(rendererId);
    if (componentEffects) {
      componentEffects.forEach((effect) => {
        if (effect.cleanup)
          effect.cleanup();
      });
      effects.set(rendererId, []);
    }
    if (globalRenderCallback && globalContainer && currentElement) {
      await globalRenderCallback(currentElement, globalContainer);
    }
  } catch (error) {
    console.error("Error during rerender:", error);
  }
}
function useErrorBoundary() {
  const [error, setError] = useState(null);
  return [error, () => setError(null)];
}
function createContext(defaultValue) {
  const context = {
    Provider: ({ value, children }) => {
      return children;
    },
    Consumer: ({ children }) => {
      return children(defaultValue);
    },
    _id: Symbol(),
    useSelector: (selector) => {
      return selector(defaultValue);
    }
  };
  return context;
}
function useContext(context) {
  return context;
}
function jsx(type, props) {
  console.log("JSX Transform:", { type, props });
  const processedProps = { ...props };
  if (arguments.length > 2) {
    processedProps.children = Array.prototype.slice.call(arguments, 2);
  }
  return { type, props: processedProps };
}
var Fragment = ({ children }) => children;
async function createElement(vnode) {
  var _a;
  console.log("Creating element from:", vnode);
  if (vnode == null) {
    return document.createTextNode("");
  }
  if (typeof vnode === "boolean") {
    return document.createTextNode("");
  }
  if (typeof vnode === "number" || typeof vnode === "string") {
    return document.createTextNode(String(vnode));
  }
  if (Array.isArray(vnode)) {
    const fragment = document.createDocumentFragment();
    for (const child of vnode) {
      const node = await createElement(child);
      fragment.appendChild(node);
    }
    return fragment;
  }
  if ("type" in vnode && vnode.props !== void 0) {
    const { type, props } = vnode;
    if (typeof type === "function") {
      try {
        const result = await type(props || {});
        const node = await createElement(result);
        if (node instanceof Element) {
          node.setAttribute("data-component-id", type.name || type.toString());
        }
        return node;
      } catch (error) {
        console.error("Error rendering component:", error);
        return document.createTextNode("");
      }
    }
    const element = document.createElement(type);
    for (const [key, value] of Object.entries(props || {})) {
      if (key === "children")
        continue;
      if (key.startsWith("on") && typeof value === "function") {
        const eventName = key.toLowerCase().slice(2);
        const existingHandler = (_a = element.__events) == null ? void 0 : _a[eventName];
        if (existingHandler) {
          element.removeEventListener(eventName, existingHandler);
        }
        element.addEventListener(eventName, value);
        if (!element.__events) {
          element.__events = {};
        }
        element.__events[eventName] = value;
      } else if (key === "style" && typeof value === "object") {
        Object.assign(element.style, value);
      } else if (key === "className") {
        element.setAttribute("class", String(value));
      } else if (key !== "key" && key !== "ref") {
        element.setAttribute(key, String(value));
      }
    }
    const children = props == null ? void 0 : props.children;
    if (children != null) {
      const childArray = Array.isArray(children) ? children.flat() : [children];
      for (const child of childArray) {
        const childNode = await createElement(child);
        element.appendChild(childNode);
      }
    }
    return element;
  }
  return document.createTextNode(String(vnode));
}
var isHydrating = false;
async function hydrate(element, container) {
  isHydrating = true;
  try {
    await render(element, container);
  } finally {
    isHydrating = false;
  }
}
async function render(element, container) {
  console.log("Rendering to:", container.id);
  batchUpdates(async () => {
    const rendererId = prepareRender();
    try {
      setRenderCallback(render, element, container);
      const domNode = await createElement(element);
      if (!isHydrating) {
        container.innerHTML = "";
      }
      container.appendChild(domNode);
    } finally {
      finishRender();
    }
  });
}
var server = {
  async getServer() {
    throw new Error("Server module can only be used in Node.js environment");
  }
};

// src/wasm.ts
async function loadGoWasm(wasmUrl, options = {}) {
  if (typeof window === "undefined") {
    throw new Error("loadGoWasm() is for browser use only. Use loadGoWasmFromFile() in Node.js.");
  }
  try {
    if (!window.Go) {
      throw new Error("Go WASM runtime not available. Make sure wasm_exec.js is loaded.");
    }
    if (options.debug) {
      console.log("[WASM] Loading WASM from:", wasmUrl);
    }
    const response = await fetch(wasmUrl);
    if (!response.ok) {
      throw new Error(`Failed to fetch WASM file: ${response.status}`);
    }
    const wasmBytes = await response.arrayBuffer();
    const go = new window.Go();
    const wasmModule = await WebAssembly.instantiate(wasmBytes, go.importObject);
    go.run(wasmModule.instance);
    await new Promise((resolve) => setTimeout(resolve, 100));
    if (options.debug) {
      console.log("[WASM] Go program started, checking for registered functions...");
    }
    const functions = {};
    for (const key in window) {
      if (typeof window[key] === "function" && key.startsWith("go")) {
        functions[key] = window[key];
        if (options.debug) {
          console.log(`[WASM] Found function: ${key}`);
        }
      }
    }
    const wasmInstance = {
      instance: wasmModule.instance,
      module: wasmModule,
      exports: wasmModule.instance.exports,
      functions
    };
    if (options.onLoad) {
      options.onLoad(wasmInstance);
    }
    if (options.debug) {
      console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
    }
    return wasmInstance;
  } catch (error) {
    console.error("[WASM] Error loading Go WASM module:", error);
    throw error;
  }
}
function callWasmFunction(funcName, ...args) {
  if (typeof window === "undefined") {
    throw new Error("callWasmFunction() is for browser use only.");
  }
  const func = window[funcName];
  if (typeof func !== "function") {
    throw new Error(`Function ${funcName} not found. Make sure the WASM module is loaded.`);
  }
  return func(...args);
}
function isWasmReady() {
  if (typeof window === "undefined") {
    return false;
  }
  return !!(window.Go && Object.keys(window).some(
    (key) => key.startsWith("go") && typeof window[key] === "function"
  ));
}
function getWasmFunctions() {
  if (typeof window === "undefined") {
    return [];
  }
  return Object.keys(window).filter(
    (key) => key.startsWith("go") && typeof window[key] === "function"
  );
}
function useGoWasm(wasmUrl, options = {}) {
  if (typeof window === "undefined") {
    throw new Error("useGoWasm() is for browser use only.");
  }
  return {
    loadWasm: () => loadGoWasm(wasmUrl, options),
    callFunction: callWasmFunction,
    isReady: isWasmReady,
    getFunctions: getWasmFunctions
  };
}

// src/browser.ts
var safeJsonParse = (json, fallback) => {
  try {
    return JSON.parse(json);
  } catch {
    return fallback;
  }
};
var generateToken = (length = 32) => {
  const array = new Uint8Array(length);
  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
    crypto.getRandomValues(array);
  } else {
    for (let i = 0; i < array.length; i++) {
      array[i] = Math.floor(Math.random() * 256);
    }
  }
  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
};
var generateDocument = (content, options = {}) => `<!DOCTYPE html><html><head><title>${options.title || "App"}</title></head><body>${content}</body></html>`;
var generateErrorPage = (code, message) => `<div>Error ${code}: ${message}</div>`;
var generateLoadingPage = (message = "Loading...") => `<div>${message}</div>`;
var renderToString = (component) => {
  try {
    if (typeof component === "function") {
      const result = component();
      return typeof result === "string" ? result : String(result || "");
    }
    return String(component || "");
  } catch (error) {
    return "<div>Error rendering component</div>";
  }
};
var createServer = () => {
  throw new Error("createServer is not available in browser environment");
};
var createDevServer = () => {
  throw new Error("createDevServer is not available in browser environment");
};
var createProductionServer = () => {
  throw new Error("createProductionServer is not available in browser environment");
};
var BaraqexServer = null;
var Database = null;
var AuthService = null;
var ApiRouter = null;
var requestLogger = null;
var errorHandler = null;
var notFoundHandler = null;
var rateLimit = null;
var initNodeWasm = null;
var loadGoWasmFromFile = null;
var hashString = null;
var getPagination = null;
var sendSuccess = null;
var sendError = null;
var validateFields = null;
var validateFileUpload = null;
var getEnvironmentInfo = null;
var isDirectoryEmpty = null;
var ensureDirectory = null;
var writeJsonFile = null;
var readJsonFile = null;
var baraqexRenderToString = null;
var renderComponent = null;
console.log("Baraqex - Browser build loaded");
export {
  ApiRouter,
  AuthService,
  BaraqexServer,
  Database,
  Fragment,
  baraqexRenderToString,
  batchUpdates,
  callWasmFunction,
  createContext,
  createDevServer,
  createProductionServer,
  createServer,
  ensureDirectory,
  errorHandler,
  generateDocument,
  generateErrorPage,
  generateLoadingPage,
  generateToken,
  getEnvironmentInfo,
  getPagination,
  getWasmFunctions,
  hashString,
  hydrate,
  initNodeWasm,
  isDirectoryEmpty,
  isWasmReady,
  jsx,
  jsx as jsxs,
  loadGoWasm,
  loadGoWasmFromFile,
  notFoundHandler,
  rateLimit,
  readJsonFile,
  render,
  renderComponent,
  renderToString,
  requestLogger,
  safeJsonParse,
  sendError,
  sendSuccess,
  server,
  useContext,
  useEffect,
  useErrorBoundary,
  useGoWasm,
  useMemo,
  useRef,
  useState,
  validateFields,
  validateFileUpload,
  writeJsonFile
};
//# sourceMappingURL=browser.js.map