baraqex 1.0.42 → 1.0.44

package/dist/browser.js

@@ -1,82 +1,4 @@
-// node_modules/frontend-hamroun/dist/index.js
-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) {
-  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 = element.__events?.[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?.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));
-}
+// node_modules/frontend-hamroun/dist/index.mjs
 var isBatching = false;
 var queue = [];
 function batchUpdates(fn) {
@@ -89,35 +11,13 @@ function batchUpdates(fn) {
     fn();
     while (queue.length > 0) {
       const nextFn = queue.shift();
-      nextFn?.();
+      nextFn == null ? void 0 : nextFn();
     }
   } finally {
     isBatching = false;
   }
 }
-var contexts = /* @__PURE__ */ new Map();
-function createContext(defaultValue) {
-  const contextId = Symbol("context");
-  const Provider = ({ value, children }) => {
-    contexts.set(contextId, value);
-    return children;
-  };
-  const Consumer = ({ children }) => {
-    const value = contexts.get(contextId) ?? defaultValue;
-    return children(value);
-  };
-  const context = {
-    Provider,
-    Consumer,
-    displayName: "Context"
-  };
-  return context;
-}
-function useContext(context) {
-  return {};
-}
 var currentRender = 0;
-var isSSR = false;
 var states = /* @__PURE__ */ new Map();
 var stateIndices = /* @__PURE__ */ new Map();
 var effects = /* @__PURE__ */ new Map();
@@ -126,39 +26,53 @@ 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(component = null, isServerSideRender = false) {
+function prepareRender() {
   currentRender++;
-  isSSR = isServerSideRender;
   stateIndices.set(currentRender, 0);
-  if (!states.has(currentRender)) {
-    states.set(currentRender, []);
-  }
   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) || 0;
+  const index = stateIndices.get(currentRender);
   if (index >= componentStates.length) {
     componentStates.push(initial);
   }
   const state = componentStates[index];
   const setState = (newValue) => {
-    if (isSSR) {
-      return;
-    }
     const nextValue = typeof newValue === "function" ? newValue(componentStates[index]) : newValue;
     if (componentStates[index] === nextValue)
       return;
@@ -175,24 +89,19 @@ function useState(initial) {
 function useEffect(callback, deps) {
   if (!currentRender)
     throw new Error("useEffect must be called within a render");
-  if (isSSR) {
-    const effectIndex2 = stateIndices.get(currentRender) || 0;
-    stateIndices.set(currentRender, effectIndex2 + 1);
-    return;
-  }
-  const effectIndex = stateIndices.get(currentRender) || 0;
+  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?.cleanup) {
+    if (prevEffect == null ? void 0 : prevEffect.cleanup) {
       prevEffect.cleanup();
     }
     queueMicrotask(() => {
       const cleanup = callback() || void 0;
-      componentEffects[effectIndex] = { cleanup, deps: deps || [] };
+      componentEffects[effectIndex] = { cleanup, deps };
     });
   }
   stateIndices.set(currentRender, effectIndex + 1);
@@ -200,7 +109,7 @@ function useEffect(callback, deps) {
 function useMemo(factory, deps) {
   if (!currentRender)
     throw new Error("useMemo must be called within a render");
-  const memoIndex = stateIndices.get(currentRender) || 0;
+  const memoIndex = stateIndices.get(currentRender);
   if (!memos.has(currentRender)) {
     memos.set(currentRender, []);
   }
@@ -208,7 +117,7 @@ function useMemo(factory, deps) {
   const prevMemo = componentMemos[memoIndex];
   if (!prevMemo || deps && deps.some((dep, i) => !Object.is(dep, prevMemo.deps[i]))) {
     const value = factory();
-    componentMemos[memoIndex] = { value, deps: deps || [] };
+    componentMemos[memoIndex] = { value, deps };
     stateIndices.set(currentRender, memoIndex + 1);
     return value;
   }
@@ -218,7 +127,7 @@ function useMemo(factory, deps) {
 function useRef(initial) {
   if (!currentRender)
     throw new Error("useRef must be called within a render");
-  const refIndex = stateIndices.get(currentRender) || 0;
+  const refIndex = stateIndices.get(currentRender);
   if (!refs.has(currentRender)) {
     refs.set(currentRender, []);
   }
@@ -235,9 +144,6 @@ function useRef(initial) {
 }
 async function rerender(rendererId) {
   try {
-    if (isSSR) {
-      return;
-    }
     const componentEffects = effects.get(rendererId);
     if (componentEffects) {
       componentEffects.forEach((effect) => {
@@ -257,640 +163,133 @@ function useErrorBoundary() {
   const [error, setError] = useState(null);
   return [error, () => setError(null)];
 }
-async function render(element, container) {
-  try {
-    setRenderCallback(render, element, container);
-    const renderId = prepareRender(element);
-    const domNode = await createElement(element);
-    if (container instanceof Element) {
-      container.innerHTML = "";
-    } else {
-      while (container.firstChild) {
-        container.removeChild(container.firstChild);
-      }
+function createContext(defaultValue) {
+  const context = {
+    Provider: ({ value, children }) => {
+      return children;
+    },
+    Consumer: ({ children }) => {
+      return children(defaultValue);
+    },
+    _id: Symbol(),
+    useSelector: (selector) => {
+      return selector(defaultValue);
     }
-    container.appendChild(domNode);
-    finishRender();
-    console.log("Render completed successfully");
-  } catch (error) {
-    console.error("Error during render:", error);
-    throw error;
-  }
-}
-async function hydrate(element, container) {
-  try {
-    console.log("Starting hydration...");
-    await render(element, container);
-    console.log("Hydration completed successfully");
-  } catch (error) {
-    console.error("Error during hydration:", error);
-    throw error;
-  }
-}
-function arePropsEqual(oldProps, newProps) {
-  const oldKeys = Object.keys(oldProps).filter((k) => k !== "children");
-  const newKeys = Object.keys(newProps).filter((k) => k !== "children");
-  if (oldKeys.length !== newKeys.length)
-    return false;
-  return oldKeys.every((key) => oldProps[key] === newProps[key]);
-}
-function diff(oldNode, newNode) {
-  if (oldNode == null || newNode == null)
-    return oldNode !== newNode;
-  if (typeof oldNode !== typeof newNode)
-    return true;
-  if (typeof newNode === "string" || typeof newNode === "number")
-    return oldNode !== newNode;
-  if (newNode.type !== oldNode.type)
-    return true;
-  return !arePropsEqual(oldNode.props, newNode.props);
+  };
+  return context;
 }
-function shouldComponentUpdate(oldProps, newProps) {
-  return !arePropsEqual(oldProps, newProps);
+function useContext(context) {
+  return context;
 }
-var Component = class {
-  constructor(props = {}) {
-    this.state = {};
-    this.element = null;
-    this._mounted = false;
-    this.props = props;
-  }
-  componentDidMount() {
-  }
-  async setState(newState) {
-    const prevState = { ...this.state };
-    this.state = { ...prevState, ...newState };
-    console.log(`${this.constructor.name} state updated:`, {
-      prev: prevState,
-      next: this.state
-    });
-    await Promise.resolve();
-    if (this._mounted) {
-      await this.update();
-    } else {
-      await this.update();
-    }
+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);
   }
-  _replayEvents(oldElement, newElement) {
-    const oldEvents = oldElement.__events || {};
-    Object.entries(oldEvents).forEach(([event, handler]) => {
-      newElement.addEventListener(event, handler);
-    });
-    newElement.__events = oldEvents;
+  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("");
   }
-  _deepCloneWithEvents(node) {
-    const clone = node.cloneNode(false);
-    const events = node.__events || {};
-    clone.__events = events;
-    Object.entries(events).forEach(([event, handler]) => {
-      clone.addEventListener(event, handler);
-    });
-    Array.from(node.childNodes).forEach((child) => {
-      if (child instanceof HTMLElement) {
-        clone.appendChild(this._deepCloneWithEvents(child));
-      } else {
-        clone.appendChild(child.cloneNode(true));
-      }
-    });
-    return clone;
+  if (typeof vnode === "boolean") {
+    return document.createTextNode("");
   }
-  async update() {
-    const vdom = this.render();
-    if (!vdom)
-      return document.createTextNode("");
-    const rendered = await createElement(vdom);
-    if (rendered instanceof HTMLElement) {
-      return this._updateElement(rendered);
-    }
-    const wrapper = document.createElement("div");
-    wrapper.appendChild(rendered);
-    return this._updateElement(wrapper);
+  if (typeof vnode === "number" || typeof vnode === "string") {
+    return document.createTextNode(String(vnode));
   }
-  async _updateElement(rendered) {
-    const newElement = this._deepCloneWithEvents(rendered);
-    newElement.__instance = this;
-    if (!this.element) {
-      this.element = newElement;
-      if (!this._mounted) {
-        this._mounted = true;
-        queueMicrotask(() => this.componentDidMount());
-      }
-    } else if (this.element.parentNode) {
-      this.element.parentNode.replaceChild(newElement, this.element);
-      this.element = newElement;
+  if (Array.isArray(vnode)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of vnode) {
+      const node = await createElement(child);
+      fragment.appendChild(node);
     }
-    return this.element;
-  }
-  render() {
-    throw new Error("Component must implement render() method");
+    return fragment;
   }
-};
-var RouterContext = createContext({
-  location: {
-    pathname: "/",
-    search: "",
-    hash: ""
-  },
-  params: {},
-  navigate: () => {
-  },
-  match: () => false
-});
-function parsePath(path) {
-  const pattern = path.replace(/\/+$/, "").replace(/^\/+/, "/").replace(/\/:([^/]+)/g, "/([^/]+)");
-  const paramNames = [];
-  path.replace(/\/:([^/]+)/g, (_, paramName) => {
-    paramNames.push(paramName);
-    return "";
-  });
-  return { pattern, paramNames };
-}
-function matchPath(pathname, route) {
-  const { path, exact = false } = route;
-  const { pattern, paramNames } = parsePath(path);
-  const regex = new RegExp(`^${pattern}${exact ? "$" : ""}`);
-  const match = pathname.match(regex);
-  if (!match)
-    return null;
-  const params = {};
-  paramNames.forEach((name, index) => {
-    params[name] = match[index + 1];
-  });
-  return params;
-}
-function RouterProvider({ routes, children }) {
-  const getInitialLocation = () => {
-    if (typeof window === "undefined") {
-      return { pathname: "/", search: "", hash: "" };
-    }
-    return {
-      pathname: window.location.pathname,
-      search: window.location.search,
-      hash: window.location.hash
-    };
-  };
-  const [location, setLocation] = useState(getInitialLocation());
-  const [params, setParams] = useState({});
-  useEffect(() => {
-    for (const route of routes) {
-      const matchedParams = matchPath(location.pathname, route);
-      if (matchedParams) {
-        setParams(matchedParams);
-        break;
-      }
-    }
-  }, [location, routes]);
-  useEffect(() => {
-    if (typeof window === "undefined")
-      return;
-    const handlePopState = () => {
-      setLocation({
-        pathname: window.location.pathname,
-        search: window.location.search,
-        hash: window.location.hash
-      });
-    };
-    window.addEventListener("popstate", handlePopState);
-    return () => window.removeEventListener("popstate", handlePopState);
-  }, []);
-  const navigate = (to, options = {}) => {
-    if (typeof window === "undefined")
-      return;
-    const { replace = false, state = null } = options;
-    if (replace) {
-      window.history.replaceState(state, "", to);
-    } else {
-      window.history.pushState(state, "", to);
-    }
-    setLocation({
-      pathname: window.location.pathname,
-      search: window.location.search,
-      hash: window.location.hash
-    });
-  };
-  const match = (path) => {
-    const { pattern } = parsePath(path);
-    const regex = new RegExp(`^${pattern}`);
-    return regex.test(location.pathname);
-  };
-  const routerValue = {
-    location: {
-      pathname: location.pathname,
-      search: location.search,
-      hash: location.hash
-    },
-    params,
-    navigate,
-    match
-  };
-  return jsx(RouterContext.Provider, { value: routerValue, children });
-}
-function Route({ path, component: Component2, props = {} }) {
-  const context = useContext();
-  const params = context.params;
-  const locationPathname = context.location.pathname;
-  const routeToMatch = { path, component: Component2 };
-  const match = matchPath(locationPathname, routeToMatch);
-  if (!match)
-    return null;
-  return jsx(Component2, { ...props, params });
-}
-function Switch({ children }) {
-  const context = useContext();
-  const locationPathname = context.location.pathname;
-  const child = Array.isArray(children) ? children.find((child2) => {
-    if (!child2 || typeof child2.type !== "function" || !child2.props.path)
-      return false;
-    const routeObj = {
-      path: child2.props.path,
-      component: child2.type,
-      exact: child2.props.exact || false
-    };
-    return matchPath(locationPathname, routeObj);
-  }) : children;
-  return child || null;
-}
-function Link({ to, replace = false, state = null, className = "", activeClassName = "", children, ...rest }) {
-  const context = useContext();
-  const navigate = context.navigate;
-  const match = context.match;
-  const handleClick = (e) => {
-    e.preventDefault();
-    navigate(to, { replace, state });
-  };
-  const isActive = match(to);
-  const classes = [
-    className,
-    isActive ? activeClassName : ""
-  ].filter(Boolean).join(" ");
-  return jsx("a", {
-    href: to,
-    className: classes || void 0,
-    onClick: handleClick,
-    ...rest,
-    children
-  });
-}
-function Redirect({ to, replace = true }) {
-  const context = useContext();
-  const navigate = context.navigate;
-  useEffect(() => {
-    navigate(to, { replace });
-  }, [to]);
-  return null;
-}
-function useLocation() {
-  const context = useContext();
-  return context.location;
-}
-function useParams() {
-  const context = useContext();
-  return context.params;
-}
-function useNavigate() {
-  const context = useContext();
-  return context.navigate;
-}
-function useForm(options) {
-  const { initialValues, validate, onSubmit } = options;
-  const [values, setValues] = useState(initialValues);
-  const [errors, setErrors] = useState({});
-  const [touched, setTouched] = useState({});
-  const [dirty, setDirty] = useState({});
-  const [isSubmitting, setIsSubmitting] = useState(false);
-  const [submitCount, setSubmitCount] = useState(0);
-  const isValid = Object.keys(errors).length === 0;
-  const isDirty = Object.values(dirty).some(Boolean);
-  useEffect(() => {
-    if (validate) {
-      const validationErrors = validate(values);
-      setErrors(validationErrors || {});
-    }
-  }, [values, validate]);
-  const handleChange = (e) => {
-    const { name, value, type, checked } = e.target;
-    const fieldValue = type === "checkbox" ? checked : value;
-    setValues((prev) => ({
-      ...prev,
-      [name]: fieldValue
-    }));
-    setDirty((prev) => ({
-      ...prev,
-      [name]: true
-    }));
-  };
-  const handleBlur = (e) => {
-    const { name } = e.target;
-    setTouched((prev) => ({
-      ...prev,
-      [name]: true
-    }));
-  };
-  const setFieldValue = (field, value) => {
-    setValues((prev) => ({
-      ...prev,
-      [field]: value
-    }));
-    setDirty((prev) => ({
-      ...prev,
-      [field]: true
-    }));
-  };
-  const setFieldError = (field, error) => {
-    setErrors((prev) => ({
-      ...prev,
-      [field]: error
-    }));
-  };
-  const updateValues = (newValues) => {
-    setValues((prev) => ({
-      ...prev,
-      ...newValues
-    }));
-    const dirtyFields = {};
-    Object.keys(newValues).forEach((key) => {
-      dirtyFields[key] = true;
-    });
-    setDirty((prev) => ({
-      ...prev,
-      ...dirtyFields
-    }));
-  };
-  const resetForm = () => {
-    setValues(initialValues);
-    setErrors({});
-    setTouched({});
-    setDirty({});
-    setIsSubmitting(false);
-  };
-  const handleSubmit = async (e) => {
-    e.preventDefault();
-    const allTouched = {};
-    Object.keys(values).forEach((key) => {
-      allTouched[key] = true;
-    });
-    setTouched(allTouched);
-    let validationErrors = {};
-    if (validate) {
-      validationErrors = validate(values);
-      setErrors(validationErrors || {});
-    }
-    if (Object.keys(validationErrors).length === 0 && onSubmit) {
-      setIsSubmitting(true);
-      setSubmitCount((count) => count + 1);
+  if ("type" in vnode && vnode.props !== void 0) {
+    const { type, props } = vnode;
+    if (typeof type === "function") {
       try {
-        await onSubmit(values, {
-          fields: Object.keys(values).reduce((acc, key) => {
-            acc[key] = {
-              value: values[key],
-              error: errors[key],
-              touched: touched[key] || false,
-              dirty: dirty[key] || false
-            };
-            return acc;
-          }, {}),
-          isValid,
-          isDirty,
-          isSubmitting: true,
-          submitCount: submitCount + 1
-        });
-      } finally {
-        setIsSubmitting(false);
+        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("");
       }
     }
-  };
-  return {
-    values,
-    errors,
-    touched,
-    dirty,
-    isValid,
-    isDirty,
-    isSubmitting,
-    submitCount,
-    handleChange,
-    handleBlur,
-    handleSubmit,
-    setFieldValue,
-    setFieldError,
-    setValues: updateValues,
-    resetForm
-  };
-}
-function createEventBus() {
-  const events = /* @__PURE__ */ new Map();
-  const onceHandlers = /* @__PURE__ */ new WeakMap();
-  const on = (event, handler) => {
-    if (!events.has(event)) {
-      events.set(event, /* @__PURE__ */ new Set());
-    }
-    events.get(event).add(handler);
-    return () => off(event, handler);
-  };
-  const once = (event, handler) => {
-    const onceWrapper = (...args) => {
-      off(event, onceWrapper);
-      handler(...args);
-    };
-    onceHandlers.set(handler, onceWrapper);
-    return on(event, onceWrapper);
-  };
-  const off = (event, handler) => {
-    if (!handler) {
-      events.delete(event);
-      return;
-    }
-    const wrappedHandler = onceHandlers.get(handler);
-    const handlerToRemove = wrappedHandler || handler;
-    if (events.has(event)) {
-      events.get(event).delete(handlerToRemove);
-      if (events.get(event).size === 0) {
-        events.delete(event);
+    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 emit = (event, ...args) => {
-    if (!events.has(event)) {
-      return;
-    }
-    const handlers = Array.from(events.get(event));
-    for (const handler of handlers) {
-      handler(...args);
-    }
-  };
-  const clear = (event) => {
-    if (event) {
-      events.delete(event);
-    } else {
-      events.clear();
+    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 { on, once, off, emit, clear };
-}
-var globalEventBus = createEventBus();
-function useEvent(event, handler, options = {}) {
-  return options.once ? globalEventBus.once(event, handler) : globalEventBus.on(event, handler);
-}
-function createStore(reducer, initialState, middlewares = []) {
-  let state = initialState;
-  let listeners = [];
-  let dispatch = (action) => {
-    state = reducer(state, action);
-    listeners.forEach((listener) => listener());
-    return action;
-  };
-  if (middlewares.length > 0) {
-    const middlewareAPI = {
-      getState: () => state,
-      dispatch: (action) => dispatch(action),
-      subscribe: (listener) => subscribe(listener)
-    };
-    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
-    dispatch = chain.reduce((a, b) => (next) => a(b(next)))(dispatch);
+    return element;
   }
-  function subscribe(listener) {
-    listeners.push(listener);
-    return function unsubscribe() {
-      listeners = listeners.filter((l) => l !== listener);
-    };
+  return document.createTextNode(String(vnode));
+}
+var isHydrating = false;
+async function hydrate(element, container) {
+  isHydrating = true;
+  try {
+    await render(element, container);
+  } finally {
+    isHydrating = false;
   }
-  dispatch({ type: "@@INIT" });
-  return {
-    getState: () => state,
-    dispatch,
-    subscribe
-  };
 }
-var StoreContext = createContext({
-  store: {
-    getState: () => ({}),
-    dispatch: () => {
-    },
-    subscribe: () => () => {
+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();
     }
-  },
-  state: {}
-});
-function StoreProvider({ store, children }) {
-  const [state, setState] = useState(store.getState());
-  useEffect(() => {
-    const unsubscribe = store.subscribe(() => {
-      setState(store.getState());
-    });
-    return unsubscribe;
-  }, [store]);
-  return jsx(StoreContext.Provider, {
-    value: { store, state },
-    children
   });
 }
-function useSelector(selector) {
-  const context = useContext();
-  return selector(context.state);
-}
-function useDispatch() {
-  const context = useContext();
-  return context.store.dispatch;
-}
-function useStore() {
-  const context = useContext();
-  return context.store;
-}
-var logger = (store) => (next) => (action) => {
-  console.group(action.type);
-  console.log("Previous state:", store.getState());
-  console.log("Action:", action);
-  const result = next(action);
-  console.log("Next state:", store.getState());
-  console.groupEnd();
-  return result;
-};
-var thunk = (store) => (next) => (action) => {
-  if (typeof action === "function") {
-    return action(store.dispatch, store.getState);
+var server = {
+  async getServer() {
+    throw new Error("Server module can only be used in Node.js environment");
   }
-  return next(action);
 };
-var LifecycleEvents;
-(function(LifecycleEvents2) {
-  LifecycleEvents2["APP_INIT"] = "app:init";
-  LifecycleEvents2["APP_MOUNTED"] = "app:mounted";
-  LifecycleEvents2["APP_UPDATED"] = "app:updated";
-  LifecycleEvents2["APP_ERROR"] = "app:error";
-  LifecycleEvents2["APP_DESTROYED"] = "app:destroyed";
-  LifecycleEvents2["COMPONENT_CREATED"] = "component:created";
-  LifecycleEvents2["COMPONENT_MOUNTED"] = "component:mounted";
-  LifecycleEvents2["COMPONENT_UPDATED"] = "component:updated";
-  LifecycleEvents2["COMPONENT_ERROR"] = "component:error";
-  LifecycleEvents2["COMPONENT_UNMOUNTED"] = "component:unmounted";
-  LifecycleEvents2["ROUTER_BEFORE_CHANGE"] = "router:before-change";
-  LifecycleEvents2["ROUTER_AFTER_CHANGE"] = "router:after-change";
-  LifecycleEvents2["ROUTER_ERROR"] = "router:error";
-  LifecycleEvents2["STORE_INITIALIZED"] = "store:initialized";
-  LifecycleEvents2["STORE_BEFORE_ACTION"] = "store:before-action";
-  LifecycleEvents2["STORE_AFTER_ACTION"] = "store:after-action";
-  LifecycleEvents2["STORE_ERROR"] = "store:error";
-})(LifecycleEvents || (LifecycleEvents = {}));
-function emitAppInit(data) {
-  globalEventBus.emit(LifecycleEvents.APP_INIT, data);
-}
-function emitAppMounted(rootElement) {
-  globalEventBus.emit(LifecycleEvents.APP_MOUNTED, rootElement);
-}
-function emitAppUpdated() {
-  globalEventBus.emit(LifecycleEvents.APP_UPDATED);
-}
-function emitAppError(error) {
-  globalEventBus.emit(LifecycleEvents.APP_ERROR, error);
-}
-function emitAppDestroyed() {
-  globalEventBus.emit(LifecycleEvents.APP_DESTROYED);
-}
-function emitComponentCreated(info) {
-  globalEventBus.emit(LifecycleEvents.COMPONENT_CREATED, info);
-}
-function emitComponentMounted(info, element) {
-  globalEventBus.emit(LifecycleEvents.COMPONENT_MOUNTED, info, element);
-}
-function emitComponentUpdated(info, prevProps, newProps) {
-  globalEventBus.emit(LifecycleEvents.COMPONENT_UPDATED, info, prevProps, newProps);
-}
-function emitComponentError(info, error) {
-  globalEventBus.emit(LifecycleEvents.COMPONENT_ERROR, info, error);
-}
-function emitComponentUnmounted(info) {
-  globalEventBus.emit(LifecycleEvents.COMPONENT_UNMOUNTED, info);
-}
-function onAppInit(handler) {
-  return globalEventBus.on(LifecycleEvents.APP_INIT, handler);
-}
-function onAppMounted(handler) {
-  return globalEventBus.on(LifecycleEvents.APP_MOUNTED, handler);
-}
-function onAppUpdated(handler) {
-  return globalEventBus.on(LifecycleEvents.APP_UPDATED, handler);
-}
-function onAppError(handler) {
-  return globalEventBus.on(LifecycleEvents.APP_ERROR, handler);
-}
-function onAppDestroyed(handler) {
-  return globalEventBus.on(LifecycleEvents.APP_DESTROYED, handler);
-}
-function onComponentCreated(handler) {
-  return globalEventBus.on(LifecycleEvents.COMPONENT_CREATED, handler);
-}
-function onComponentMounted(handler) {
-  return globalEventBus.on(LifecycleEvents.COMPONENT_MOUNTED, handler);
-}
-function onComponentUpdated(handler) {
-  return globalEventBus.on(LifecycleEvents.COMPONENT_UPDATED, handler);
-}
-function onComponentError(handler) {
-  return globalEventBus.on(LifecycleEvents.COMPONENT_ERROR, handler);
-}
-function onComponentUnmounted(handler) {
-  return globalEventBus.on(LifecycleEvents.COMPONENT_UNMOUNTED, handler);
-}
 
 // src/wasm.ts
 async function loadGoWasm(wasmUrl, options = {}) {
@@ -981,194 +380,50 @@ function useGoWasm(wasmUrl, options = {}) {
   };
 }
 
-// src/server/templates.ts
+// src/browser.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>` : "";
+  const { title = "App", description = "", styles = [], scripts = [] } = options;
   return `<!DOCTYPE html>
-<html lang="${lang}" ${htmlAttributes}>
+<html lang="en">
 <head>
-  ${metaTags.filter(Boolean).join("\n  ")}
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>${escapeHtml(title)}</title>
-  ${styleTags.join("\n  ")}
+  ${description ? `<meta name="description" content="${escapeHtml(description)}">` : ""}
+  ${styles.map((href) => `<link rel="stylesheet" href="${escapeHtml(href)}">`).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>
+  <div id="app-root">${content}</div>
+  ${scripts.map((src) => `<script src="${escapeHtml(src)}" defer><\/script>`).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">
+function generateErrorPage(statusCode, message) {
+  return generateDocument(`
+    <div style="text-align: center; padding: 2rem;">
       <h1>${statusCode}</h1>
-      <h2>${escapeHtml(errorMessages[statusCode] || "Error")}</h2>
       <p>${escapeHtml(message)}</p>
-      ${errorDetails}
-      <a href="/" class="home-link">Back to Home</a>
+      <a href="/">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
-  });
+  `, { title: `Error ${statusCode}` });
 }
 function generateLoadingPage(message = "Loading...") {
-  const content = `
-    <div class="loading-container">
-      <div class="spinner"></div>
+  return generateDocument(`
+    <div style="text-align: center; padding: 2rem;">
+      <div style="display: inline-block; width: 40px; height: 40px; border: 4px solid #f3f3f3; border-top: 4px solid #3498db; border-radius: 50%; animation: spin 1s linear infinite;"></div>
       <p>${escapeHtml(message)}</p>
+      <style>
+        @keyframes spin {
+          0% { transform: rotate(0deg); }
+          100% { transform: rotate(360deg); }
+        }
+      </style>
     </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
-  });
+  `, { title: "Loading" });
 }
 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 content;
@@ -1203,78 +458,60 @@ function safeJsonParse(json, fallback) {
 }
 var isBrowser = typeof window !== "undefined";
 var isNode = false;
+var Server = null;
+var createServer = null;
+var createDevServer = null;
+var createProductionServer = 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;
 console.log("Baraqex - Browser version loaded");
 export {
-  Component,
+  ApiRouter,
+  AuthService,
+  Database,
   Fragment,
-  LifecycleEvents,
-  Link,
-  Redirect,
-  Route,
-  RouterProvider,
-  StoreProvider,
-  Switch,
+  Server,
   batchUpdates,
   callWasmFunction,
   createContext,
-  createElement,
-  createEventBus,
-  createStore,
-  diff,
-  emitAppDestroyed,
-  emitAppError,
-  emitAppInit,
-  emitAppMounted,
-  emitAppUpdated,
-  emitComponentCreated,
-  emitComponentError,
-  emitComponentMounted,
-  emitComponentUnmounted,
-  emitComponentUpdated,
-  globalEventBus as eventBus,
+  createDevServer,
+  createProductionServer,
+  createServer,
+  errorHandler,
   generateDocument,
   generateErrorPage,
   generateLoadingPage,
   generateToken,
   getWasmFunctions,
   hydrate,
+  initNodeWasm,
   isBrowser,
   isNode,
   isWasmReady,
   jsx,
-  jsx as jsxDEV,
   jsx as jsxs,
   loadGoWasm,
-  logger,
-  onAppDestroyed,
-  onAppError,
-  onAppInit,
-  onAppMounted,
-  onAppUpdated,
-  onComponentCreated,
-  onComponentError,
-  onComponentMounted,
-  onComponentUnmounted,
-  onComponentUpdated,
+  loadGoWasmFromFile,
+  notFoundHandler,
+  rateLimit,
   render,
   renderToString,
+  requestLogger,
   safeJsonParse,
-  shouldComponentUpdate,
-  thunk,
+  server,
   useContext,
-  useDispatch,
   useEffect,
   useErrorBoundary,
-  useEvent,
-  useForm,
   useGoWasm,
-  useLocation,
   useMemo,
-  useNavigate,
-  useParams,
   useRef,
-  useSelector,
-  useState,
-  useStore
+  useState
 };
 //# sourceMappingURL=browser.js.map