@fynixorg/ui 1.0.11 → 1.0.13

package/dist/router/router.js

@@ -1,530 +1,564 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function isExternal(url) {
-  return /^https?:\/\//.test(url);
-}
-__name(isExternal, "isExternal");
-import { mount } from "../runtime.js";
+import { mount } from "../runtime";
 const MAX_CACHE_SIZE = 50;
 const PROPS_NAMESPACE = "__fynixLinkProps__";
 const MAX_LISTENERS = 100;
 const ALLOWED_PROTOCOLS = ["http:", "https:", ""];
+const RENDER_DEBOUNCE = 10;
 let routerInstance = null;
 let isRouterInitialized = false;
+function isExternal(url) {
+    return /^https?:\/\//.test(url);
+}
 function escapeHTML(str) {
-  if (typeof str !== "string")
-    return "";
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;").replace(/`/g, "&#96;").replace(/\//g, "&#x2F;");
+    if (typeof str !== "string")
+        return "";
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;")
+        .replace(/`/g, "&#96;")
+        .replace(/\//g, "&#x2F;");
 }
-__name(escapeHTML, "escapeHTML");
 function isValidURL(url) {
-  try {
-    const parsed = new URL(url, window.location.origin);
-    if (parsed.origin !== window.location.origin) {
-      console.warn("[Router] Security: Cross-origin navigation blocked");
-      return false;
-    }
-    if (!ALLOWED_PROTOCOLS.includes(parsed.protocol)) {
-      console.warn(
-        "[Router] Security: Dangerous protocol blocked:",
-        parsed.protocol
-      );
-      return false;
-    }
-    return true;
-  } catch (e) {
-    console.warn("[Router] Security: Invalid URL blocked");
-    return false;
-  }
+    try {
+        const parsed = new URL(url, window.location.origin);
+        if (parsed.origin !== window.location.origin) {
+            console.warn("[Router] Security: Cross-origin navigation blocked");
+            return false;
+        }
+        if (!ALLOWED_PROTOCOLS.includes(parsed.protocol)) {
+            console.warn("[Router] Security: Dangerous protocol blocked:", parsed.protocol);
+            return false;
+        }
+        return true;
+    }
+    catch (e) {
+        console.warn("[Router] Security: Invalid URL blocked");
+        return false;
+    }
 }
-__name(isValidURL, "isValidURL");
 function sanitizePath(path) {
-  if (typeof path !== "string")
-    return "/";
-  try {
-    path = decodeURIComponent(path);
-  } catch (e) {
-    console.warn("[Router] Invalid URL encoding in path");
-    return "/";
-  }
-  path = path.replace(/\0/g, "");
-  path = path.replace(/\\/g, "/");
-  path = path.replace(/\/+/g, "/");
-  path = path.split("/").filter((part) => part !== ".." && part !== ".").join("/");
-  if (!path.startsWith("/")) {
-    path = "/" + path;
-  }
-  if (path.length > 1 && path.endsWith("/")) {
-    path = path.slice(0, -1);
-  }
-  return path || "/";
+    if (typeof path !== "string")
+        return "/";
+    try {
+        path = decodeURIComponent(path);
+    }
+    catch (e) {
+        console.warn("[Router] Invalid URL encoding in path");
+        return "/";
+    }
+    path = path.replace(/\0/g, "");
+    path = path.replace(/\\/g, "/");
+    path = path.replace(/\/+/g, "/");
+    path = path
+        .split("/")
+        .filter((part) => part !== ".." && part !== ".")
+        .join("/");
+    if (!path.startsWith("/")) {
+        path = "/" + path;
+    }
+    if (path.length > 1 && path.endsWith("/")) {
+        path = path.slice(0, -1);
+    }
+    return path || "/";
 }
-__name(sanitizePath, "sanitizePath");
 function tryGlobPaths() {
-  try {
-    const modules = import.meta.glob("/src/**/*.{ts,js,jsx,fnx}", {
-      eager: true
-    });
-    return modules || {};
-  } catch (error) {
-    console.error("[Router] Failed to load modules:", error);
-    return {};
-  }
+    try {
+        let modules = import.meta.glob("/src/**/*.{fnx,tsx,jsx,ts,js}", {
+            eager: true,
+        });
+        console.log("[Router] Glob attempt 1 (/src/**):", Object.keys(modules));
+        if (Object.keys(modules).length === 0) {
+            modules = import.meta.glob(["./**/*.fnx", "./**/*.tsx", "./**/*.jsx", "./**/*.ts", "./**/*.js"], { eager: true });
+            console.log("[Router] Glob attempt 2 (./**):", Object.keys(modules));
+        }
+        if (Object.keys(modules).length === 0) {
+            modules = import.meta.glob(["../**/*.fnx", "../**/*.tsx", "../**/*.jsx"], { eager: true });
+            console.log("[Router] Glob attempt 3 (../**):", Object.keys(modules));
+        }
+        console.log("[Router] Final modules loaded:", Object.keys(modules).length);
+        return modules || {};
+    }
+    catch (error) {
+        console.error("[Router] Failed to load modules:", error);
+        return {};
+    }
 }
-__name(tryGlobPaths, "tryGlobPaths");
 function filePathToRoute(filePath) {
-  let route = filePath.replace(/^.*\/src/, "").replace(/\.(js|jsx|fnx)$/, "").replace(/\/view$/, "").replace(/\/$/, "");
-  if (!route)
-    route = "/";
-  route = route.replace(/\[([^\]]+)\]/g, ":$1");
-  return route;
+    let route = filePath
+        .replace(/^.*\/src/, "")
+        .replace(/\.(ts|tsx|js|jsx|fnx)$/, "")
+        .replace(/\/view$/, "")
+        .replace(/\/$/, "");
+    if (!route)
+        route = "/";
+    route = route.replace(/\[([^\]]+)\]/g, ":$1");
+    return route;
 }
-__name(filePathToRoute, "filePathToRoute");
 function matchDynamicRoute(path, dynamicRoutes) {
-  for (const route of dynamicRoutes) {
-    const match = path.match(route.regex);
-    if (match) {
-      const params = {};
-      route.params.forEach((param, i) => {
-        params[param] = escapeHTML(match[i + 1]);
-      });
-      return { component: route.component, params };
-    }
-  }
-  return null;
+    for (const route of dynamicRoutes) {
+        const match = path.match(route.regex);
+        if (match) {
+            const params = {};
+            route.params.forEach((param, i) => {
+                const matchValue = match[i + 1];
+                params[param] = escapeHTML(matchValue || "");
+            });
+            return { component: route.component, params };
+        }
+    }
+    return null;
 }
-__name(matchDynamicRoute, "matchDynamicRoute");
 function deserializeProps(props) {
-  if (!props || typeof props !== "object")
-    return {};
-  const deserialized = {};
-  for (const [key, value] of Object.entries(props)) {
-    if (typeof key !== "string" || key.startsWith("__")) {
-      continue;
+    if (!props || typeof props !== "object")
+        return {};
+    const deserialized = {};
+    for (const [key, value] of Object.entries(props)) {
+        if (typeof key !== "string" || key.startsWith("__")) {
+            continue;
+        }
+        deserialized[key] = value;
     }
-    deserialized[key] = value;
-  }
-  return deserialized;
+    return deserialized;
 }
-__name(deserializeProps, "deserializeProps");
 function normalizePath(path) {
-  return sanitizePath(path);
+    return sanitizePath(path);
 }
-__name(normalizePath, "normalizePath");
 function generateCacheKey() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return `${Date.now()}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return `${Date.now()}-${Math.random().toString(36).slice(2)}-${Math.random()
+        .toString(36)
+        .slice(2)}`;
 }
-__name(generateCacheKey, "generateCacheKey");
-function createFynix() {
-  const isDevMode = import.meta.hot !== void 0;
-  if (routerInstance && isRouterInitialized && !isDevMode) {
-    console.warn(
-      "[Router] Router already initialized, returning existing instance"
-    );
-    return routerInstance;
-  }
-  if (isDevMode && routerInstance) {
-    console.log("[Router] HMR: Cleaning up old router instance");
-    routerInstance.cleanup();
-    routerInstance = null;
-    isRouterInitialized = false;
-  }
-  let rootSelector = "#app-root";
-  let currentPath = null;
-  let isDestroyed = false;
-  let listenerCount = 0;
-  const listeners = [];
-  if (!window[PROPS_NAMESPACE]) {
-    window[PROPS_NAMESPACE] = {};
-  }
-  if (isDevMode && window.__fynixPropsCache) {
-    window.__fynixPropsCache.clear();
-  }
-  const __fynixPropsCache = window.__fynixPropsCache || /* @__PURE__ */ new Map();
-  window.__fynixPropsCache = __fynixPropsCache;
-  const modules = tryGlobPaths();
-  const routes = {};
-  const dynamicRoutes = [];
-  for (const [filePath, mod] of Object.entries(modules)) {
-    const routePath = filePathToRoute(filePath);
-    const component = mod.default || mod[Object.keys(mod)[0]] || Object.values(mod)[0];
-    if (!component)
-      continue;
-    const hasDynamic = /:[^/]+/.test(routePath);
-    if (hasDynamic) {
-      dynamicRoutes.push({
-        pattern: routePath,
-        regex: new RegExp("^" + routePath.replace(/:[^/]+/g, "([^/]+)") + "$"),
-        component,
-        params: [...routePath.matchAll(/:([^/]+)/g)].map((m) => m[1])
-      });
-    } else {
-      routes[routePath] = component;
-    }
-  }
-  function addToCache(key, value) {
-    if (__fynixPropsCache.size >= MAX_CACHE_SIZE) {
-      const firstKey = __fynixPropsCache.keys().next().value;
-      const evicted = __fynixPropsCache.get(firstKey);
-      if (evicted && typeof evicted === "object") {
-        Object.values(evicted).forEach((val) => {
-          if (val && typeof val === "object" && val.cleanup) {
-            try {
-              val.cleanup();
-            } catch (e) {
+function addToCache(cache, key, value) {
+    if (cache.size >= MAX_CACHE_SIZE) {
+        const firstKey = cache.keys().next().value;
+        if (typeof firstKey === "string") {
+            const evicted = cache.get(firstKey);
+            if (evicted && typeof evicted === "object") {
+                Object.values(evicted).forEach((val) => {
+                    if (val && typeof val === "object" && "cleanup" in val) {
+                        try {
+                            val.cleanup();
+                        }
+                        catch (e) {
+                        }
+                    }
+                });
             }
-          }
-        });
-      }
-      __fynixPropsCache.delete(firstKey);
+            cache.delete(firstKey);
+        }
     }
-    __fynixPropsCache.set(key, value);
-  }
-  __name(addToCache, "addToCache");
-  const MANAGED_META = [
+    cache.set(key, value);
+}
+const MANAGED_META = [
     { key: "description", name: "description" },
     { key: "keywords", name: "keywords" },
     { key: "twitterCard", name: "twitter:card" },
     { key: "ogTitle", property: "og:title" },
     { key: "ogDescription", property: "og:description" },
-    { key: "ogImage", property: "og:image" }
-  ];
-  function updateMetaTags(meta = {}) {
+    { key: "ogImage", property: "og:image" },
+];
+function updateMetaTags(meta = {}) {
     if (!meta || typeof meta !== "object")
-      return;
+        return;
     if (meta.title && typeof meta.title === "string") {
-      document.title = escapeHTML(meta.title);
+        document.title = escapeHTML(meta.title);
     }
     MANAGED_META.forEach((def) => {
-      const value = meta[def.key];
-      const selector = def.name ? `meta[name="${def.name}"]` : `meta[property="${def.property}"]`;
-      let el = document.querySelector(selector);
-      if (value == null) {
-        if (el)
-          el.remove();
-        return;
-      }
-      if (typeof value !== "string")
-        return;
-      if (!el) {
-        el = document.createElement("meta");
-        if (def.name)
-          el.setAttribute("name", def.name);
-        if (def.property)
-          el.setAttribute("property", def.property);
-        document.head.appendChild(el);
-      }
-      el.setAttribute("content", escapeHTML(value));
+        const value = meta[def.key];
+        const selector = def.name
+            ? `meta[name="${def.name}"]`
+            : `meta[property="${def.property}"]`;
+        let el = document.querySelector(selector);
+        if (value == null) {
+            if (el)
+                el.remove();
+            return;
+        }
+        if (typeof value !== "string")
+            return;
+        if (!el) {
+            el = document.createElement("meta");
+            if (def.name)
+                el.setAttribute("name", def.name);
+            if (def.property)
+                el.setAttribute("property", def.property);
+            document.head.appendChild(el);
+        }
+        el.setAttribute("content", escapeHTML(value));
     });
-  }
-  __name(updateMetaTags, "updateMetaTags");
-  let renderTimeout = null;
-  const RENDER_DEBOUNCE = 10;
-  function renderRoute() {
-    if (isDestroyed)
-      return;
-    if (renderTimeout) {
-      clearTimeout(renderTimeout);
-    }
-    renderTimeout = setTimeout(() => {
-      _renderRouteImmediate();
-      renderTimeout = null;
-    }, RENDER_DEBOUNCE);
-  }
-  __name(renderRoute, "renderRoute");
-  function _renderRouteImmediate() {
-    if (isDestroyed)
-      return;
-    const path = normalizePath(window.location.pathname);
-    let Page = routes[path];
-    let params = {};
-    let routeProps = {};
-    if (!Page) {
-      const match = matchDynamicRoute(path, dynamicRoutes);
-      if (match) {
-        Page = match.component;
-        params = match.params;
-      }
-    }
-    const root = document.querySelector(rootSelector);
-    if (!root) {
-      console.error("[Router] Root element not found:", rootSelector);
-      return;
-    }
-    if (!Page) {
-      root.innerHTML = `<h2>404 Not Found</h2><p>Path: ${escapeHTML(path)}</p>`;
-      updateMetaTags({ title: "404 - Page Not Found" });
-      return;
-    }
-    const state = window.history.state || {};
-    let passedProps = {};
-    if (state.__fynixCacheKey && __fynixPropsCache.has(state.__fynixCacheKey)) {
-      passedProps = __fynixPropsCache.get(state.__fynixCacheKey);
-    } else if (state.serializedProps) {
-      passedProps = deserializeProps(state.serializedProps);
-    }
-    if (Page.props) {
-      routeProps = typeof Page.props === "function" ? Page.props() : Page.props;
-    }
-    if (Page.meta) {
-      const meta = typeof Page.meta === "function" ? Page.meta(params) : Page.meta;
-      updateMetaTags(meta);
-    }
-    window.__lastRouteProps = {
-      ...routeProps,
-      ...passedProps,
-      params
+}
+function createFynix() {
+    const isDevMode = import.meta.hot !== undefined;
+    if (routerInstance && isRouterInitialized && !isDevMode) {
+        console.warn("[Router] Router already initialized, returning existing instance");
+        return routerInstance;
+    }
+    if (isDevMode && routerInstance) {
+        console.log("[Router] HMR: Cleaning up old router instance");
+        routerInstance.cleanup();
+        routerInstance = null;
+        isRouterInitialized = false;
+    }
+    let rootSelector = "#app-root";
+    let currentPath = null;
+    let isDestroyed = false;
+    let listenerCount = 0;
+    let renderTimeout = null;
+    const listeners = [];
+    if (!window[PROPS_NAMESPACE]) {
+        window[PROPS_NAMESPACE] = {};
+    }
+    if (isDevMode && window.__fynixPropsCache) {
+        window.__fynixPropsCache.clear();
+    }
+    const propsCache = window.__fynixPropsCache || new Map();
+    window.__fynixPropsCache = propsCache;
+    const modules = tryGlobPaths();
+    const routes = {};
+    const dynamicRoutes = [];
+    for (const [filePath, mod] of Object.entries(modules)) {
+        const routePath = filePathToRoute(filePath);
+        let component = undefined;
+        if (mod && typeof mod === "object") {
+            if ("default" in mod && mod.default) {
+                component = mod.default;
+            }
+            else {
+                const keys = Object.keys(mod);
+                const firstKey = keys.length > 0 ? keys[0] : undefined;
+                if (firstKey !== undefined &&
+                    typeof firstKey === "string" &&
+                    typeof mod[firstKey] !== "undefined") {
+                    component = mod[firstKey];
+                }
+                else {
+                    const values = Object.values(mod).filter(Boolean);
+                    if (values.length > 0) {
+                        component = values[0];
+                    }
+                }
+            }
+        }
+        if (!component || typeof routePath !== "string")
+            continue;
+        const hasDynamic = /:[^/]+/.test(routePath);
+        if (hasDynamic) {
+            dynamicRoutes.push({
+                pattern: routePath,
+                regex: new RegExp("^" + routePath.replace(/:[^/]+/g, "([^/]+)") + "$"),
+                component,
+                params: [...routePath.matchAll(/:([^/]+)/g)]
+                    .map((m) => m[1])
+                    .filter((p) => typeof p === "string"),
+            });
+        }
+        else {
+            routes[routePath] = component;
+        }
+    }
+    function renderRouteImmediate() {
+        if (isDestroyed)
+            return;
+        const path = normalizePath(window.location.pathname);
+        let Page = routes[path];
+        let params = {};
+        let routeProps = {};
+        if (!Page) {
+            const match = matchDynamicRoute(path, dynamicRoutes);
+            if (match) {
+                Page = match.component;
+                params = match.params;
+            }
+        }
+        const root = document.querySelector(rootSelector);
+        if (!root) {
+            console.error("[Router] Root element not found:", rootSelector);
+            return;
+        }
+        if (!Page) {
+            root.innerHTML = `<h2>404 Not Found</h2><p>Path: ${escapeHTML(path)}</p>`;
+            updateMetaTags({ title: "404 - Page Not Found" });
+            return;
+        }
+        const state = (window.history.state || {});
+        let passedProps = {};
+        if (state.__fynixCacheKey && propsCache.has(state.__fynixCacheKey)) {
+            passedProps = propsCache.get(state.__fynixCacheKey);
+        }
+        else if (state.serializedProps) {
+            passedProps = deserializeProps(state.serializedProps);
+        }
+        if (Page.props) {
+            routeProps = typeof Page.props === "function" ? Page.props() : Page.props;
+        }
+        if (Page.meta) {
+            const meta = typeof Page.meta === "function" ? Page.meta(params) : Page.meta;
+            updateMetaTags(meta);
+        }
+        window.__lastRouteProps = {
+            ...routeProps,
+            ...passedProps,
+            params,
+        };
+        try {
+            mount(Page, rootSelector, window.__lastRouteProps);
+        }
+        catch (err) {
+            console.error("[Router] Mount failed:", err);
+            root.innerHTML = `<pre style="color:red;">Mount Error occurred</pre>`;
+        }
+        currentPath = path;
+    }
+    function renderRoute() {
+        if (isDestroyed)
+            return;
+        if (renderTimeout) {
+            clearTimeout(renderTimeout);
+        }
+        renderTimeout = setTimeout(async () => {
+            await renderRouteImmediate();
+            renderTimeout = null;
+        }, RENDER_DEBOUNCE);
+    }
+    function navigate(path, props = {}) {
+        if (isDestroyed)
+            return;
+        const normalizedPath = normalizePath(path);
+        if (!isValidURL(window.location.origin + normalizedPath)) {
+            console.error("[Router] Invalid navigation URL");
+            return;
+        }
+        if (normalizedPath === currentPath)
+            return;
+        const cacheKey = generateCacheKey();
+        addToCache(propsCache, cacheKey, props);
+        try {
+            window.history.pushState({ __fynixCacheKey: cacheKey }, "", normalizedPath);
+            renderRoute();
+        }
+        catch (err) {
+            console.error("[Router] Navigation failed:", err);
+        }
+    }
+    function replace(path, props = {}) {
+        if (isDestroyed)
+            return;
+        const normalizedPath = normalizePath(path);
+        if (!isValidURL(window.location.origin + normalizedPath)) {
+            console.error("[Router] Invalid replace URL");
+            return;
+        }
+        const cacheKey = generateCacheKey();
+        addToCache(propsCache, cacheKey, props);
+        try {
+            window.history.replaceState({ __fynixCacheKey: cacheKey }, "", normalizedPath);
+            renderRoute();
+        }
+        catch (err) {
+            console.error("[Router] Replace failed:", err);
+        }
+    }
+    function back() {
+        if (isDestroyed)
+            return;
+        try {
+            window.history.back();
+        }
+        catch (err) {
+            console.error("[Router] Back navigation failed:", err);
+        }
+    }
+    const clickHandler = (e) => {
+        if (isDestroyed)
+            return;
+        const target = e.target;
+        const link = target.closest("a[data-fynix-link]");
+        if (!link)
+            return;
+        const href = link.getAttribute("href");
+        if (!href) {
+            console.warn("[Router] Missing href attribute");
+            return;
+        }
+        if (isExternal(href)) {
+            return;
+        }
+        const fullUrl = new URL(link.href, window.location.origin).href;
+        if (!isValidURL(fullUrl)) {
+            console.warn("[Router] Invalid link href");
+            return;
+        }
+        e.preventDefault();
+        const path = normalizePath(new URL(link.href, window.location.origin).pathname);
+        if (path === currentPath)
+            return;
+        let props = {};
+        const propsKey = link.getAttribute("data-props-key");
+        if (propsKey &&
+            typeof propsKey === "string" &&
+            !propsKey.startsWith("__")) {
+            if (window[PROPS_NAMESPACE]?.[propsKey]) {
+                props = window[PROPS_NAMESPACE][propsKey];
+            }
+        }
+        const serializableProps = {};
+        for (const [k, v] of Object.entries(props)) {
+            if (typeof k !== "string" || k.startsWith("__"))
+                continue;
+            serializableProps[k] =
+                v && (v._isNixState || v._isRestState) ? v.value : v;
+        }
+        const cacheKey = generateCacheKey();
+        addToCache(propsCache, cacheKey, serializableProps);
+        try {
+            window.history.pushState({ __fynixCacheKey: cacheKey, serializedProps: serializableProps }, "", path);
+            renderRoute();
+        }
+        catch (err) {
+            console.error("[Router] Link navigation failed:", err);
+        }
     };
-    try {
-      mount(Page, rootSelector, false, window.__lastRouteProps);
-    } catch (err) {
-      console.error("[Router] Mount failed:", err);
-      root.innerHTML = `<pre style="color:red;">Mount Error occurred</pre>`;
-    }
-    currentPath = path;
-  }
-  __name(_renderRouteImmediate, "_renderRouteImmediate");
-  function navigate(path, props = {}) {
-    if (isDestroyed)
-      return;
-    path = normalizePath(path);
-    if (!isValidURL(window.location.origin + path)) {
-      console.error("[Router] Invalid navigation URL");
-      return;
-    }
-    if (path === currentPath)
-      return;
-    const cacheKey = generateCacheKey();
-    addToCache(cacheKey, props);
-    try {
-      window.history.pushState({ __fynixCacheKey: cacheKey }, "", path);
-      renderRoute();
-    } catch (err) {
-      console.error("[Router] Navigation failed:", err);
-    }
-  }
-  __name(navigate, "navigate");
-  function replace(path, props = {}) {
-    if (isDestroyed)
-      return;
-    path = normalizePath(path);
-    if (!isValidURL(window.location.origin + path)) {
-      console.error("[Router] Invalid replace URL");
-      return;
-    }
-    const cacheKey = generateCacheKey();
-    addToCache(cacheKey, props);
-    try {
-      window.history.replaceState({ __fynixCacheKey: cacheKey }, "", path);
-      renderRoute();
-    } catch (err) {
-      console.error("[Router] Replace failed:", err);
-    }
-  }
-  __name(replace, "replace");
-  function back() {
-    if (isDestroyed)
-      return;
-    try {
-      window.history.back();
-    } catch (err) {
-      console.error("[Router] Back navigation failed:", err);
-    }
-  }
-  __name(back, "back");
-  function mountRouter(selector = "#app-root") {
-    if (isDestroyed) {
-      console.error("[Router] Cannot mount destroyed router");
-      return;
-    }
-    if (typeof selector !== "string" || selector.length === 0) {
-      console.error("[Router] Invalid selector");
-      return;
-    }
-    rootSelector = selector;
-    renderRoute();
-    isRouterInitialized = true;
-  }
-  __name(mountRouter, "mountRouter");
-  const clickHandler = /* @__PURE__ */ __name((e) => {
-    if (isDestroyed)
-      return;
-    const link = e.target.closest("a[data-fynix-link]");
-    if (!link)
-      return;
-    const href = link.getAttribute("href");
-    if (!href) {
-      console.warn("[Router] Missing href attribute");
-      return;
-    }
-    if (isExternal(href)) {
-      return;
-    }
-    const fullUrl = new URL(link.href, window.location.origin).href;
-    if (!isValidURL(fullUrl)) {
-      console.warn("[Router] Invalid link href");
-      return;
-    }
-    e.preventDefault();
-    const path = normalizePath(
-      new URL(link.href, window.location.origin).pathname
-    );
-    if (path === currentPath)
-      return;
-    let props = {};
-    const propsKey = link.getAttribute("data-props-key");
-    if (propsKey && typeof propsKey === "string" && !propsKey.startsWith("__")) {
-      if (window[PROPS_NAMESPACE]?.[propsKey]) {
-        props = window[PROPS_NAMESPACE][propsKey];
-      }
-    }
-    const serializableProps = {};
-    for (const [k, v] of Object.entries(props)) {
-      if (typeof k !== "string" || k.startsWith("__"))
-        continue;
-      serializableProps[k] = v && (v._isNixState || v._isRestState) ? v.value : v;
-    }
-    const cacheKey = generateCacheKey();
-    addToCache(cacheKey, serializableProps);
-    try {
-      window.history.pushState(
-        { __fynixCacheKey: cacheKey, serializedProps: serializableProps },
-        "",
-        path
-      );
-      renderRoute();
-    } catch (err) {
-      console.error("[Router] Link navigation failed:", err);
-    }
-  }, "clickHandler");
-  if (listenerCount < MAX_LISTENERS && !isRouterInitialized) {
-    document.addEventListener("click", clickHandler);
-    listeners.push({
-      element: document,
-      event: "click",
-      handler: clickHandler
-    });
-    listenerCount++;
-    window.addEventListener("popstate", renderRoute);
-    listeners.push({
-      element: window,
-      event: "popstate",
-      handler: renderRoute
-    });
-    listenerCount++;
-  }
-  function cleanup() {
-    if (renderTimeout) {
-      clearTimeout(renderTimeout);
-      renderTimeout = null;
-    }
-    isDestroyed = true;
-    listeners.forEach(({ element, event, handler }) => {
-      try {
-        element.removeEventListener(event, handler);
-      } catch (e) {
-        console.error("[Router] Cleanup error:", e);
-      }
-    });
-    listeners.length = 0;
-    listenerCount = 0;
-    __fynixPropsCache.forEach((props) => {
-      if (props && typeof props === "object") {
-        Object.values(props).forEach((val) => {
-          if (val && typeof val === "object" && val.cleanup) {
+    if (listenerCount < MAX_LISTENERS && !isRouterInitialized) {
+        document.addEventListener("click", clickHandler);
+        listeners.push({
+            element: document,
+            event: "click",
+            handler: clickHandler,
+        });
+        listenerCount++;
+        window.addEventListener("popstate", renderRoute);
+        listeners.push({
+            element: window,
+            event: "popstate",
+            handler: renderRoute,
+        });
+        listenerCount++;
+    }
+    function mountRouter(selector = "#app-root") {
+        if (isDestroyed) {
+            console.error("[Router] Cannot mount destroyed router");
+            return;
+        }
+        if (typeof selector !== "string" || selector.length === 0) {
+            console.error("[Router] Invalid selector");
+            return;
+        }
+        rootSelector = selector;
+        renderRoute();
+        isRouterInitialized = true;
+    }
+    function cleanup() {
+        if (renderTimeout) {
+            clearTimeout(renderTimeout);
+            renderTimeout = null;
+        }
+        isDestroyed = true;
+        listeners.forEach(({ element, event, handler }) => {
             try {
-              val.cleanup();
-            } catch (e) {
+                element.removeEventListener(event, handler);
+            }
+            catch (e) {
+                console.error("[Router] Cleanup error:", e);
             }
-          }
         });
-      }
-    });
-    __fynixPropsCache.clear();
-    if (window[PROPS_NAMESPACE]) {
-      Object.keys(window[PROPS_NAMESPACE]).forEach((key) => {
-        delete window[PROPS_NAMESPACE][key];
-      });
-      delete window[PROPS_NAMESPACE];
-    }
-    if (window.__lastRouteProps) {
-      delete window.__lastRouteProps;
-    }
-    isRouterInitialized = false;
-    routerInstance = null;
-    console.log("[Router] Cleanup complete");
-  }
-  __name(cleanup, "cleanup");
-  if (import.meta.hot) {
-    import.meta.hot.accept(() => {
-      console.log("[Router] HMR detected, re-rendering route...");
-      renderRoute();
-    });
-    import.meta.hot.dispose(() => {
-      console.log("[Router] HMR dispose, cleaning up...");
-      cleanup();
-      routerInstance = null;
-      isRouterInitialized = false;
-    });
-  }
-  const router = {
-    mountRouter,
-    navigate,
-    replace,
-    back,
-    cleanup,
-    routes,
-    dynamicRoutes
-  };
-  routerInstance = router;
-  return router;
+        listeners.length = 0;
+        listenerCount = 0;
+        propsCache.forEach((props) => {
+            if (props && typeof props === "object") {
+                Object.values(props).forEach((val) => {
+                    if (val && typeof val === "object" && "cleanup" in val) {
+                        try {
+                            val.cleanup();
+                        }
+                        catch (e) {
+                        }
+                    }
+                });
+            }
+        });
+        propsCache.clear();
+        if (window[PROPS_NAMESPACE]) {
+            const ns = window[PROPS_NAMESPACE];
+            if (ns && typeof ns === "object") {
+                Object.keys(ns).forEach((key) => {
+                    delete ns[key];
+                });
+            }
+            delete window[PROPS_NAMESPACE];
+        }
+        if (window.__lastRouteProps) {
+            delete window.__lastRouteProps;
+        }
+        isRouterInitialized = false;
+        routerInstance = null;
+        console.log("[Router] Cleanup complete");
+    }
+    if (import.meta.hot) {
+        import.meta.hot.accept(() => {
+            console.log("[Router] HMR detected, re-rendering route...");
+            renderRoute();
+        });
+        import.meta.hot.dispose(() => {
+            console.log("[Router] HMR dispose, cleaning up...");
+            cleanup();
+            routerInstance = null;
+            isRouterInitialized = false;
+        });
+    }
+    const router = {
+        mountRouter,
+        navigate,
+        replace,
+        back,
+        cleanup,
+        routes,
+        dynamicRoutes,
+    };
+    routerInstance = router;
+    return router;
 }
-__name(createFynix, "createFynix");
-function setLinkProps(key, props) {
-  if (typeof key !== "string" || key.startsWith("__")) {
-    console.error("[Router] Invalid props key");
-    return;
-  }
-  if (!props || typeof props !== "object") {
-    console.error("[Router] Invalid props object");
-    return;
-  }
-  if (!window[PROPS_NAMESPACE]) {
-    window[PROPS_NAMESPACE] = {};
-  }
-  if (Object.keys(window[PROPS_NAMESPACE]).length >= MAX_CACHE_SIZE) {
-    console.warn("[Router] Props storage limit reached");
-    return;
-  }
-  window[PROPS_NAMESPACE][key] = props;
+export { createFynix };
+export default createFynix;
+export function setLinkProps(key, props) {
+    if (typeof key !== "string" || key.startsWith("__")) {
+        console.error("[Router] Invalid props key");
+        return;
+    }
+    if (!props || typeof props !== "object") {
+        console.error("[Router] Invalid props object");
+        return;
+    }
+    if (!window[PROPS_NAMESPACE]) {
+        window[PROPS_NAMESPACE] = {};
+    }
+    if (Object.keys(window[PROPS_NAMESPACE]).length >= MAX_CACHE_SIZE) {
+        console.warn("[Router] Props storage limit reached");
+        return;
+    }
+    window[PROPS_NAMESPACE][key] = props;
 }
-__name(setLinkProps, "setLinkProps");
-function clearLinkProps(key) {
-  if (typeof key !== "string")
-    return;
-  if (window[PROPS_NAMESPACE]?.[key]) {
-    const props = window[PROPS_NAMESPACE][key];
-    if (props && typeof props === "object") {
-      Object.values(props).forEach((val) => {
-        if (val && typeof val === "object" && val.cleanup) {
-          try {
-            val.cleanup();
-          } catch (e) {
-          }
-        }
-      });
-    }
-    delete window[PROPS_NAMESPACE][key];
-  }
+export function clearLinkProps(key) {
+    if (typeof key !== "string")
+        return;
+    if (window[PROPS_NAMESPACE]?.[key]) {
+        const props = window[PROPS_NAMESPACE][key];
+        if (props && typeof props === "object") {
+            Object.values(props).forEach((val) => {
+                if (val && typeof val === "object" && "cleanup" in val) {
+                    try {
+                        val.cleanup();
+                    }
+                    catch (e) {
+                    }
+                }
+            });
+        }
+        delete window[PROPS_NAMESPACE][key];
+    }
 }
-__name(clearLinkProps, "clearLinkProps");
-export {
-  clearLinkProps,
-  createFynix,
-  createFynix as default,
-  setLinkProps
-};
-//# sourceMappingURL=router.js.map