baraqex 1.0.35 → 1.0.36

package/dist/browser.js

@@ -0,0 +1,635 @@
+// 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/server/templates.ts
+function generateDocument(content, options = {}) {
+  const {
+    title = "Frontend Hamroun App",
+    description = "",
+    lang = "en",
+    charset = "UTF-8",
+    viewport = "width=device-width, initial-scale=1.0",
+    scripts = [],
+    styles = [],
+    meta = {},
+    bodyClasses = "",
+    htmlAttrs = {},
+    bodyAttrs = {},
+    initialData = {},
+    componentName = ""
+  } = options;
+  const htmlAttributes = Object.entries(htmlAttrs).map(([key, value]) => `${key}="${escapeHtml(value)}"`).join(" ");
+  const bodyAttributes = Object.entries(bodyAttrs).map(([key, value]) => `${key}="${escapeHtml(value)}"`).join(" ");
+  const metaTags = [
+    `<meta charset="${charset}">`,
+    `<meta name="viewport" content="${viewport}">`,
+    description ? `<meta name="description" content="${escapeHtml(description)}">` : ""
+  ];
+  Object.entries(meta).forEach(([name, content2]) => {
+    metaTags.push(`<meta name="${escapeHtml(name)}" content="${escapeHtml(content2)}">`);
+  });
+  const scriptTags = scripts.map((src) => {
+    if (src.startsWith("<script")) {
+      return src;
+    }
+    return `<script src="${escapeHtml(src)}" ${src.endsWith(".js") ? 'type="module"' : ""} defer><\/script>`;
+  });
+  const styleTags = styles.map((href) => {
+    if (href.startsWith("<style")) {
+      return href;
+    }
+    return `<link rel="stylesheet" href="${escapeHtml(href)}">`;
+  });
+  const initialDataScript = Object.keys(initialData).length > 0 ? `<script id="__APP_DATA__" type="application/json">${escapeHtml(JSON.stringify(initialData))}<\/script>` : "";
+  return `<!DOCTYPE html>
+<html lang="${lang}" ${htmlAttributes}>
+<head>
+  ${metaTags.filter(Boolean).join("\n  ")}
+  <title>${escapeHtml(title)}</title>
+  ${styleTags.join("\n  ")}
+</head>
+<body class="${bodyClasses}" ${bodyAttributes}>
+  <div id="app-root" data-ssr-root${componentName ? ` data-component="${escapeHtml(componentName)}"` : ""}>${content}</div>
+  ${initialDataScript}
+  ${scriptTags.join("\n  ")}
+</body>
+</html>`;
+}
+function generateErrorPage(statusCode, message, error) {
+  const errorMessages = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error"
+  };
+  const title = `${statusCode} - ${errorMessages[statusCode] || "Error"}`;
+  const isDev = false;
+  const errorDetails = isDev && error ? `
+    <div class="error-details">
+      <pre>${escapeHtml(error.stack || error.message)}</pre>
+    </div>
+  ` : "";
+  const content = `
+    <div class="error-container">
+      <h1>${statusCode}</h1>
+      <h2>${escapeHtml(errorMessages[statusCode] || "Error")}</h2>
+      <p>${escapeHtml(message)}</p>
+      ${errorDetails}
+      <a href="/" class="home-link">Back to Home</a>
+    </div>
+  `;
+  const styles = [`<style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background-color: #f7f7f7;
+      color: #333;
+    }
+    .error-container {
+      text-align: center;
+      padding: 2rem;
+      border-radius: 8px;
+      background-color: white;
+      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+      max-width: 600px;
+      width: 100%;
+    }
+    h1 {
+      font-size: 6rem;
+      margin: 0;
+      color: #e74c3c;
+    }
+    h2 {
+      margin-top: 0;
+      margin-bottom: 1rem;
+      color: #333;
+    }
+    .error-details {
+      text-align: left;
+      margin: 2rem 0;
+      padding: 1rem;
+      background-color: #f8f8f8;
+      border-radius: 4px;
+      overflow: auto;
+    }
+    pre {
+      margin: 0;
+      font-family: monospace;
+      font-size: 0.85rem;
+      white-space: pre-wrap;
+    }
+    .home-link {
+      display: inline-block;
+      margin-top: 1.5rem;
+      padding: 0.75rem 1.5rem;
+      background-color: #3498db;
+      color: white;
+      text-decoration: none;
+      border-radius: 4px;
+      transition: background-color 0.2s;
+    }
+    .home-link:hover {
+      background-color: #2980b9;
+    }
+  </style>`];
+  return generateDocument(content, {
+    title,
+    description: `Error ${statusCode}: ${errorMessages[statusCode] || "Error"}`,
+    bodyClasses: "error-page",
+    styles
+  });
+}
+function generateLoadingPage(message = "Loading...") {
+  const content = `
+    <div class="loading-container">
+      <div class="spinner"></div>
+      <p>${escapeHtml(message)}</p>
+    </div>
+  `;
+  const styles = [`<style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background-color: #f7f7f7;
+      color: #333;
+    }
+    .loading-container {
+      text-align: center;
+    }
+    .spinner {
+      width: 50px;
+      height: 50px;
+      border: 5px solid rgba(0, 0, 0, 0.1);
+      border-radius: 50%;
+      border-top-color: #3498db;
+      animation: spin 1s ease-in-out infinite;
+      margin: 0 auto 20px;
+    }
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+  </style>`];
+  return generateDocument(content, {
+    title: "Loading",
+    bodyClasses: "loading-page",
+    styles
+  });
+}
+function escapeHtml(text) {
+  return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/browser.ts
+function renderToString(content) {
+  if (typeof content === "string") {
+    return Promise.resolve(content);
+  }
+  if (typeof content === "function") {
+    try {
+      const result = content();
+      return Promise.resolve(String(result));
+    } catch (error) {
+      return Promise.resolve(`<!-- Error rendering: ${error} -->`);
+    }
+  }
+  return Promise.resolve(String(content));
+}
+function 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("");
+}
+function safeJsonParse(json, fallback) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    return fallback;
+  }
+}
+var isBrowser = typeof window !== "undefined";
+var isNode = false;
+console.log("Baraqex - Browser version loaded");
+export {
+  Fragment,
+  batchUpdates,
+  callWasmFunction,
+  createContext,
+  generateDocument,
+  generateErrorPage,
+  generateLoadingPage,
+  generateToken,
+  getWasmFunctions,
+  hydrate,
+  isBrowser,
+  isNode,
+  isWasmReady,
+  jsx,
+  jsx as jsxs,
+  loadGoWasm,
+  render,
+  renderToString,
+  safeJsonParse,
+  server,
+  useContext,
+  useEffect,
+  useErrorBoundary,
+  useGoWasm,
+  useMemo,
+  useRef,
+  useState
+};
+//# sourceMappingURL=browser.js.map