@echojs-ecosystem/router 0.1.0

package/dist/index.js

@@ -0,0 +1,1546 @@
+import { signal, computed } from '@echojs-ecosystem/reactivity';
+import { attachRouterQueryParams } from '@echojs-ecosystem/url-state';
+import { h, createView, cx } from '@echojs-ecosystem/hyperdom';
+
+// src/core/route.ts
+
+// src/core/path.ts
+var normalizePathname = (pathname) => {
+  let path = pathname;
+  const queryIndex = path.indexOf("?");
+  if (queryIndex !== -1) path = path.slice(0, queryIndex);
+  const hashIndex = path.indexOf("#");
+  if (hashIndex !== -1) path = path.slice(0, hashIndex);
+  if (!path || path === "/") return "/";
+  path = path.replace(/\/+$/, "");
+  return path || "/";
+};
+var joinRoutePaths = (parentPath, childPath) => {
+  const parent = normalizePathname(parentPath || "/");
+  const child = childPath.trim();
+  if (!child || child === "/") return parent;
+  if (child.startsWith("/")) {
+    return normalizePathname(child);
+  }
+  const base = parent === "/" ? "" : parent;
+  return normalizePathname(`${base}/${child}`);
+};
+var splitSegments = (path) => {
+  const normalized = normalizePathname(path);
+  if (normalized === "/") return [];
+  return normalized.slice(1).split("/");
+};
+var decodeParam = (value) => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+var encodeParam = (value) => encodeURIComponent(value);
+var matchPath = (pattern, pathname) => {
+  const patternSegments = splitSegments(pattern);
+  const pathSegments = splitSegments(pathname);
+  if (patternSegments.length === 0) {
+    return { matched: pathSegments.length === 0, params: {} };
+  }
+  const params = {};
+  let pi = 0;
+  let si = 0;
+  while (pi < patternSegments.length) {
+    const segment = patternSegments[pi];
+    if (segment === "*") {
+      if (si > pathSegments.length) {
+        return { matched: false, params: {} };
+      }
+      const rest = pathSegments.slice(si).map(decodeParam).join("/");
+      params["*"] = rest;
+      return { matched: true, params };
+    }
+    if (si >= pathSegments.length) {
+      return { matched: false, params: {} };
+    }
+    if (segment.startsWith(":")) {
+      const key = segment.slice(1);
+      params[key] = decodeParam(pathSegments[si]);
+      pi += 1;
+      si += 1;
+      continue;
+    }
+    if (segment !== pathSegments[si]) {
+      return { matched: false, params: {} };
+    }
+    pi += 1;
+    si += 1;
+  }
+  if (si !== pathSegments.length) {
+    return { matched: false, params: {} };
+  }
+  return { matched: true, params };
+};
+var buildPath = (pattern, params = {}) => {
+  const segments = splitSegments(pattern);
+  if (segments.length === 0) return "/";
+  const built = segments.map((segment) => {
+    if (segment === "*") {
+      const value = params["*"] ?? "";
+      return value.split("/").map(encodeParam).join("/");
+    }
+    if (segment.startsWith(":")) {
+      const key = segment.slice(1);
+      const value = params[key];
+      if (value === void 0) {
+        throw new Error(`Missing path param "${key}" for pattern "${pattern}"`);
+      }
+      return encodeParam(value);
+    }
+    return segment;
+  });
+  return `/${built.join("/")}`;
+};
+var splitLocation = (location) => {
+  let path = location;
+  let search = "";
+  const queryIndex = path.indexOf("?");
+  if (queryIndex !== -1) {
+    search = path.slice(queryIndex);
+    path = path.slice(0, queryIndex);
+  }
+  const hashIndex = path.indexOf("#");
+  if (hashIndex !== -1) {
+    path = path.slice(0, hashIndex);
+  }
+  return {
+    pathname: normalizePathname(path),
+    search
+  };
+};
+var joinLocation = (pathname, search) => {
+  const path = normalizePathname(pathname);
+  if (!search) return path;
+  return search.startsWith("?") ? `${path}${search}` : `${path}?${search}`;
+};
+
+// src/core/route-event.ts
+var createRouteEvent = () => {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit(payload) {
+      for (const listener of listeners) {
+        listener(payload);
+      }
+    }
+  };
+};
+
+// src/core/query.ts
+var isQueryPrimitive = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var parseQuery = (search) => {
+  const raw = search.startsWith("?") ? search.slice(1) : search;
+  if (!raw) return {};
+  const params = new URLSearchParams(raw);
+  const result = {};
+  for (const [key, value] of params.entries()) {
+    result[key] = value;
+  }
+  return result;
+};
+var parseQueryValues = (search) => {
+  const raw = search.startsWith("?") ? search.slice(1) : search;
+  if (!raw) return {};
+  const params = new URLSearchParams(raw);
+  const result = {};
+  for (const key of new Set(params.keys())) {
+    const values = params.getAll(key);
+    if (values.length === 1) {
+      result[key] = coerceQueryValue(values[0]);
+      continue;
+    }
+    result[key] = values.map(coerceQueryValue);
+  }
+  return result;
+};
+var coerceQueryValue = (value) => {
+  if (value === "true") return "true";
+  if (value === "false") return "false";
+  return value;
+};
+var stringifyQuery = (query) => {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === null || value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === null || item === void 0) continue;
+        params.append(key, String(item));
+      }
+      continue;
+    }
+    if (isQueryPrimitive(value)) {
+      params.append(key, String(value));
+    }
+  }
+  const serialized = params.toString();
+  return serialized ? `?${serialized}` : "";
+};
+var mapQueryToRecord = (raw) => raw;
+
+// src/core/route.ts
+var routeStates = /* @__PURE__ */ new WeakMap();
+var getRouteState = (route) => {
+  const state = routeStates.get(route);
+  if (!state) {
+    throw new Error("Unknown route instance");
+  }
+  return state;
+};
+var bindRouteToRouter = (route, router, pathTemplate) => {
+  const state = getRouteState(route);
+  state.router = router;
+  state.pathTemplate = pathTemplate;
+};
+var createRouteModel = (name) => {
+  const $isOpened = signal(false);
+  const $params = signal(null);
+  const $query = signal({});
+  const $path = signal(null);
+  const $fullPath = signal(null);
+  const opened = createRouteEvent();
+  const closed = createRouteEvent();
+  const state = {
+    name,
+    pathTemplate: null,
+    router: null,
+    $isOpened,
+    $params,
+    $query,
+    $path,
+    $fullPath,
+    opened,
+    closed,
+    wasOpened: false
+  };
+  const go = (...args) => {
+    const [params, options] = args;
+    if (!state.router || !state.pathTemplate) {
+      throw new Error(
+        `Route${name ? ` "${name}"` : ""} is not registered in a router. Pass it to createRouter({ routes }).`
+      );
+    }
+    const pathname = buildPath(state.pathTemplate, params ?? {});
+    const search = options?.query ? stringifyQuery(options.query) : "";
+    const fullPath = joinLocation(pathname, search);
+    if (options?.replace) state.router.replace(fullPath);
+    else state.router.go(fullPath);
+  };
+  const route = {
+    name,
+    $isOpened,
+    $params,
+    $query,
+    $path,
+    $fullPath,
+    opened,
+    closed,
+    go,
+    open: go,
+    close() {
+      if (!state.router) {
+        throw new Error(`Route${name ? ` "${name}"` : ""} is not registered in a router.`);
+      }
+      state.router.closeRoute(route);
+    }
+  };
+  routeStates.set(route, state);
+  return route;
+};
+var applyRouteClosed = (state) => {
+  const wasOpened = state.wasOpened;
+  state.$isOpened.set(false);
+  state.$params.set(null);
+  state.$path.set(null);
+  state.$fullPath.set(null);
+  state.$query.set({});
+  state.wasOpened = false;
+  if (wasOpened) {
+    state.closed.emit();
+  }
+};
+var applyRouteOpened = (state, payload) => {
+  const wasOpened = state.wasOpened;
+  state.$isOpened.set(true);
+  state.$params.set(payload.params);
+  state.$query.set(payload.query);
+  state.$path.set(payload.path);
+  state.$fullPath.set(payload.fullPath);
+  state.wasOpened = true;
+  if (!wasOpened) {
+    state.opened.emit(payload);
+  }
+};
+var rawQueryToTyped = (raw) => mapQueryToRecord(raw);
+
+// src/core/create-route.ts
+var createRoute = (name) => createRouteModel(name);
+
+// src/core/navigation.ts
+var buildRouteLocation = (pathTemplate, params = {}, query) => {
+  const pathname = buildPath(pathTemplate, params);
+  const search = query ? stringifyQuery(query) : "";
+  return joinLocation(pathname, search);
+};
+var resolveRoutePath = (route, params, options) => {
+  const state = getRouteState(route);
+  if (!state.pathTemplate) {
+    throw new Error("Route is not registered in a router");
+  }
+  return buildRouteLocation(
+    state.pathTemplate,
+    params ?? {},
+    options?.query
+  );
+};
+var parseLocation = (location) => {
+  const { pathname, search } = splitLocation(location);
+  return {
+    pathname,
+    search,
+    query: parseQuery(search)
+  };
+};
+
+// src/core/route-tree.ts
+var flattenRouteTree = (configs, parentPath = "/", parent = null) => {
+  const result = [];
+  for (const config of configs) {
+    const path = joinRoutePaths(parentPath, config.path);
+    const entry = { path, route: config.route, parent };
+    result.push(entry);
+    if (config.children?.length) {
+      result.push(...flattenRouteTree(config.children, path, entry));
+    }
+  }
+  return result;
+};
+var routeDepth = (entry) => {
+  let depth = 0;
+  let cursor = entry.parent;
+  while (cursor) {
+    depth += 1;
+    cursor = cursor.parent;
+  }
+  return depth;
+};
+var isBetterMatch = (entry, best) => {
+  if (entry.path.length > best.path.length) return true;
+  if (entry.path.length < best.path.length) return false;
+  return routeDepth(entry) > routeDepth(best);
+};
+var matchRouteChain = (pathname, flatRoutes) => {
+  let best = null;
+  for (const entry of flatRoutes) {
+    const result = matchPath(entry.path, pathname);
+    if (!result.matched) continue;
+    if (!best || isBetterMatch(entry, best.entry)) {
+      best = { entry, params: result.params };
+    }
+  }
+  if (!best) return null;
+  const chain = [];
+  let cursor = best.entry;
+  while (cursor) {
+    chain.unshift(cursor);
+    cursor = cursor.parent;
+  }
+  return {
+    leaf: best.entry,
+    chain,
+    leafParams: best.params
+  };
+};
+var matchParamsForEntry = (entry, pathname) => matchPath(entry.path, pathname).params;
+
+// src/core/lazy-view.ts
+var isLazyRouteView = (page) => {
+  const state = getPageState(page);
+  return Boolean(state.viewLoader);
+};
+var ensureLazyViewLoaded = async (page, navigationId) => {
+  const state = getPageState(page);
+  const router = getRouteState(page).router;
+  if (!state.viewLoader) return true;
+  if (state.view) return true;
+  const runId = ++state.viewLoadRunId;
+  state.$viewPending.set(true);
+  state.$viewError.set(null);
+  try {
+    const module = await state.viewLoader();
+    if (runId !== state.viewLoadRunId) return false;
+    if (router && navigationId !== router.navigationId) return false;
+    const view = module?.default;
+    if (typeof view !== "function") {
+      throw new TypeError(
+        `Lazy route view "${page.name ?? "anonymous"}": dynamic import must export a default view function.`
+      );
+    }
+    state.view = view;
+    state.$viewPending.set(false);
+    return true;
+  } catch (error) {
+    if (runId !== state.viewLoadRunId) return false;
+    if (router && navigationId !== router.navigationId) return false;
+    state.$viewError.set(error);
+    state.$viewPending.set(false);
+    return false;
+  }
+};
+var cancelLazyViewLoads = (pages) => {
+  for (const page of pages) {
+    const state = getPageState(page);
+    if (!state.viewLoader) continue;
+    state.viewLoadRunId += 1;
+    state.$viewPending.set(false);
+    state.$viewError.set(null);
+  }
+};
+
+// src/core/page.ts
+var pageStates = /* @__PURE__ */ new WeakMap();
+var isPage = (value) => pageStates.has(value);
+var isLayoutPage = (value) => {
+  const state = pageStates.get(value);
+  return Boolean(state && state.kind === "layout");
+};
+var assertLayoutPage = (value, label = "layout") => {
+  assertPage(value, label);
+  if (!isLayoutPage(value)) {
+    throw new TypeError(`${label}: expected createLayoutView() instance.`);
+  }
+  return value;
+};
+var assertPage = (value, label = "createRouter") => {
+  if (!isPage(value)) {
+    throw new TypeError(
+      `${label}: only createRouteView() / createLazyRouteView() instances are allowed. Use createRoute() for redirects/guards.`
+    );
+  }
+  return value;
+};
+var getPageState = (page) => {
+  const state = pageStates.get(page);
+  if (!state) {
+    throw new Error("Unknown page instance");
+  }
+  return state;
+};
+var createRouteViewModel = (options) => {
+  const resolved = typeof options === "string" ? (() => {
+    throw new TypeError(
+      `createRouteView("${options}") requires { name, view }. Pass an options object.`
+    );
+  })() : options;
+  if (!resolved.view && !resolved.viewLoader) {
+    throw new TypeError(
+      "createRouteView() requires { view } or createLazyRouteView() requires { view: () => import(...) }."
+    );
+  }
+  const route = createRouteModel(resolved.name);
+  const baseState = getRouteState(route);
+  const $pending = signal(false);
+  const $error = signal(null);
+  const $viewPending = signal(false);
+  const $viewError = signal(null);
+  const $data = signal(null);
+  const state = {
+    ...baseState,
+    kind: "page",
+    view: resolved.view,
+    viewLoader: resolved.viewLoader,
+    viewLoadRunId: 0,
+    beforeLoad: resolved.beforeLoad,
+    loader: resolved.loader,
+    loadingView: resolved.loadingView,
+    errorView: resolved.errorView,
+    $pending,
+    $error,
+    $viewPending,
+    $viewError,
+    $data,
+    loaderRunId: 0
+  };
+  const page = route;
+  pageStates.set(page, state);
+  page.closed.subscribe(() => {
+    state.loaderRunId += 1;
+    state.viewLoadRunId += 1;
+    $pending.set(false);
+    $error.set(null);
+    $viewPending.set(false);
+    $viewError.set(null);
+    $data.set(null);
+  });
+  return Object.assign(page, {
+    $pending,
+    $error,
+    $data,
+    beforeLoad: resolved.beforeLoad,
+    loader: resolved.loader,
+    loadingView: resolved.loadingView,
+    errorView: resolved.errorView,
+    replace(...args) {
+      const [params, options2] = args;
+      page.go(
+        params,
+        { ...options2, replace: true }
+      );
+    },
+    resolve(params, options2) {
+      return resolveRoutePath(page, params ?? {}, options2);
+    },
+    isActive() {
+      return page.$isOpened.value();
+    },
+    preload() {
+      const params = page.$params.value();
+      const query = page.$query.value();
+      if (params === null) return;
+      const navigationId = ++state.loaderRunId;
+      void (async () => {
+        const viewOk = await ensureLazyViewLoaded(page, navigationId);
+        if (!viewOk) return;
+        await runPageBeforeLoad(
+          page,
+          { params, query, navigationId },
+          navigationId
+        );
+      })();
+    }
+  });
+};
+var resolveBeforeLoad = (state) => state.beforeLoad ?? state.loader;
+var runPageBeforeLoad = async (page, context, navigationId) => {
+  const state = getPageState(page);
+  const routeState = getRouteState(page);
+  const router = routeState.router;
+  const beforeLoad = resolveBeforeLoad(state);
+  if (!beforeLoad) {
+    state.$pending.set(false);
+    state.$error.set(null);
+    state.$data.set(null);
+    return true;
+  }
+  const runId = ++state.loaderRunId;
+  state.$pending.set(true);
+  state.$error.set(null);
+  try {
+    const data = await Promise.resolve(beforeLoad(context));
+    if (runId !== state.loaderRunId) return false;
+    if (router && navigationId !== router.navigationId) return false;
+    state.$data.set(data);
+    state.$pending.set(false);
+    return true;
+  } catch (error) {
+    if (runId !== state.loaderRunId) return false;
+    if (router && navigationId !== router.navigationId) return false;
+    state.$error.set(error);
+    state.$pending.set(false);
+    return false;
+  }
+};
+var runBeforeLoadChain = async (chain, pathname, query, navigationId) => {
+  for (const entry of chain) {
+    if (!isPage(entry.route)) continue;
+    const viewOk = await ensureLazyViewLoaded(entry.route, navigationId);
+    if (!viewOk) break;
+    const params = matchParamsForEntry(entry, pathname);
+    const ok = await runPageBeforeLoad(
+      entry.route,
+      {
+        params,
+        query: rawQueryToTyped(query),
+        navigationId
+      },
+      navigationId
+    );
+    if (!ok) break;
+  }
+};
+var cancelPageLoads = (pages) => {
+  cancelLazyViewLoads(pages);
+  for (const page of pages) {
+    const state = getPageState(page);
+    state.loaderRunId += 1;
+    state.$pending.set(false);
+    state.$error.set(null);
+    state.$data.set(null);
+  }
+};
+
+// src/core/create-route-view.ts
+function createRouteView(options) {
+  return createRouteViewModel(options);
+}
+
+// src/core/create-lazy-route-view.ts
+function createLazyRouteView(options) {
+  return createRouteViewModel({
+    name: options.name,
+    viewLoader: options.view,
+    beforeLoad: options.beforeLoad,
+    loadingView: options.loadingView,
+    errorView: options.errorView
+  });
+}
+
+// src/core/create-layout-view.ts
+var createLayoutView = (options) => {
+  const layout = createRouteViewModel(options);
+  getPageState(layout).kind = "layout";
+  return layout;
+};
+
+// src/histories/browser-history.ts
+var readLocation = () => {
+  const { pathname, search } = window.location;
+  return joinLocation(pathname, search);
+};
+var createBrowserHistory = () => {
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    const path = readLocation();
+    for (const listener of listeners) {
+      listener(path);
+    }
+  };
+  const onPopState = () => notify();
+  return {
+    getLocation: readLocation,
+    push(path) {
+      const { pathname, search } = splitLocation(path);
+      window.history.pushState(null, "", joinLocation(pathname, search));
+      notify();
+    },
+    replace(path) {
+      const { pathname, search } = splitLocation(path);
+      window.history.replaceState(null, "", joinLocation(pathname, search));
+      notify();
+    },
+    listen(callback) {
+      listeners.add(callback);
+      window.addEventListener("popstate", onPopState);
+      return () => {
+        listeners.delete(callback);
+        window.removeEventListener("popstate", onPopState);
+      };
+    },
+    back() {
+      window.history.back();
+    },
+    forward() {
+      window.history.forward();
+    }
+  };
+};
+
+// src/histories/hash-history.ts
+var readHashPath = () => {
+  const hash = window.location.hash;
+  if (!hash || hash === "#") return "/";
+  const raw = hash.startsWith("#") ? hash.slice(1) : hash;
+  const path = raw.startsWith("/") ? raw : `/${raw}`;
+  return normalizePathname(path);
+};
+var createHashHistory = () => {
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    const path = readHashPath();
+    for (const listener of listeners) {
+      listener(path);
+    }
+  };
+  const onHashChange = () => notify();
+  const writeHash = (path, replace) => {
+    const normalized = normalizePathname(path);
+    const next = `#${normalized}`;
+    if (replace) window.location.replace(next);
+    else window.location.hash = next;
+    notify();
+  };
+  return {
+    getLocation: readHashPath,
+    push(path) {
+      writeHash(path, false);
+    },
+    replace(path) {
+      writeHash(path, true);
+    },
+    listen(callback) {
+      listeners.add(callback);
+      window.addEventListener("hashchange", onHashChange);
+      return () => {
+        listeners.delete(callback);
+        window.removeEventListener("hashchange", onHashChange);
+      };
+    },
+    back() {
+      window.history.back();
+    },
+    forward() {
+      window.history.forward();
+    }
+  };
+};
+
+// src/histories/memory-history.ts
+var createMemoryHistory = (initialPath = "/") => {
+  let index = 0;
+  const stack = [initialPath];
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    const path = stack[index];
+    for (const listener of listeners) {
+      listener(path);
+    }
+  };
+  const getLocation = () => stack[index];
+  return {
+    getLocation,
+    push(path) {
+      stack.splice(index + 1);
+      stack.push(path);
+      index = stack.length - 1;
+      notify();
+    },
+    replace(path) {
+      stack[index] = path;
+      notify();
+    },
+    listen(callback) {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+    back() {
+      if (index <= 0) return;
+      index -= 1;
+      notify();
+    },
+    forward() {
+      if (index >= stack.length - 1) return;
+      index += 1;
+      notify();
+    }
+  };
+};
+
+// src/core/history-config.ts
+var isRouterHistory = (value) => typeof value === "object" && value !== null && "getLocation" in value && "push" in value;
+var resolveHistory = (config) => {
+  if (isRouterHistory(config)) {
+    return config;
+  }
+  if (typeof config === "string") {
+    switch (config) {
+      case "browser":
+        return createBrowserHistory();
+      case "hash":
+        return createHashHistory();
+      case "memory":
+        return createMemoryHistory("/");
+      default: {
+        const _exhaustive = config;
+        throw new TypeError(`Unknown history kind: ${_exhaustive}`);
+      }
+    }
+  }
+  return createMemoryHistory(config.initial ?? "/");
+};
+
+// src/core/auth-guard.ts
+var isDevMode = () => {
+  try {
+    return import.meta.env?.MODE === "development";
+  } catch {
+    return false;
+  }
+};
+var resolveRedirectTarget = (target, context, fallback) => {
+  if (target === void 0) return fallback;
+  return typeof target === "function" ? target(context) : target;
+};
+var isPathAllowed = (pathname, allowedPaths) => {
+  const normalized = normalizePathname(pathname);
+  for (const pattern of allowedPaths) {
+    const normalizedPattern = normalizePathname(pattern);
+    if (normalized === normalizedPattern) return true;
+    if (matchPath(normalizedPattern, normalized).matched) return true;
+  }
+  return false;
+};
+var redirectIfNeeded = (pathname, target, history, allowedPaths, label) => {
+  const normalizedTarget = normalizePathname(target);
+  const normalizedCurrent = normalizePathname(pathname);
+  if (normalizedTarget === normalizedCurrent) {
+    return true;
+  }
+  if (!isPathAllowed(normalizedTarget, allowedPaths)) {
+    const allowed = allowedPaths.join(", ");
+    const message = `[router] authorizationGuard ${label}: redirect target "${target}" is not allowed (${allowed}).`;
+    if (isDevMode()) {
+      throw new Error(message);
+    }
+    console.error(message);
+    return false;
+  }
+  history.replace(target);
+  return false;
+};
+var runAuthorizationGuard = (pathname, options, history) => {
+  const authorized = options.isAuthorized();
+  const redirectContext = (authorized2) => ({
+    pathname,
+    authorized: authorized2
+  });
+  if (!authorized) {
+    if (isPathAllowed(pathname, options.allowedUnauthorizedPaths)) {
+      return true;
+    }
+    const target = resolveRedirectTarget(
+      options.redirectTo,
+      redirectContext(false),
+      "/login"
+    );
+    return redirectIfNeeded(
+      pathname,
+      target,
+      history,
+      options.allowedUnauthorizedPaths,
+      "redirectTo"
+    );
+  }
+  if (options.allowedAuthorizedPaths?.length) {
+    if (!isPathAllowed(pathname, options.allowedAuthorizedPaths)) {
+      const target = resolveRedirectTarget(
+        options.redirectWhenAuthorized,
+        redirectContext(true),
+        "/"
+      );
+      return redirectIfNeeded(
+        pathname,
+        target,
+        history,
+        options.allowedAuthorizedPaths,
+        "redirectWhenAuthorized"
+      );
+    }
+  }
+  if (options.redirectWhenAuthorized !== void 0 && isPathAllowed(pathname, options.allowedUnauthorizedPaths)) {
+    const target = resolveRedirectTarget(
+      options.redirectWhenAuthorized,
+      redirectContext(true),
+      "/"
+    );
+    const normalizedTarget = normalizePathname(target);
+    const normalizedCurrent = normalizePathname(pathname);
+    if (normalizedTarget === normalizedCurrent) return true;
+    if (options.allowedAuthorizedPaths?.length && !isPathAllowed(normalizedTarget, options.allowedAuthorizedPaths)) {
+      const message = `[router] authorizationGuard redirectWhenAuthorized: "${target}" is not in allowedAuthorizedPaths.`;
+      if (isDevMode()) {
+        throw new Error(message);
+      }
+      console.error(message);
+      return false;
+    }
+    history.replace(target);
+    return false;
+  }
+  return true;
+};
+
+// src/core/guard-registry.ts
+var guards = [];
+var registerGuard = (options) => {
+  guards.push(options);
+  return () => {
+    const index = guards.indexOf(options);
+    if (index !== -1) guards.splice(index, 1);
+  };
+};
+var runRouteGuards = (history, matchedRoute, query) => {
+  for (const guard of guards) {
+    if (guard.route !== matchedRoute) continue;
+    if (guard.canOpen()) return true;
+    const otherwiseState = getRouteState(guard.otherwise);
+    const params = otherwiseState.$params.peek() ?? {};
+    const target = resolveRoutePath(guard.otherwise, params, { query });
+    history.replace(target);
+    return false;
+  }
+  return true;
+};
+
+// src/core/route-config.ts
+var isRouteViewEntry = (item) => "routeView" in item && !("layoutView" in item);
+var toRouteConfigs = (definitions) => {
+  const walk2 = (items, parentPath = "") => {
+    const result = [];
+    for (const item of items) {
+      const path = parentPath ? `${parentPath}/${item.path}`.replace(/\/+/g, "/") : item.path;
+      if ("route" in item && !("routeView" in item) && !("layoutView" in item)) {
+        const childConfigs = "children" in item && item.children?.length ? walk2(item.children, path) : void 0;
+        result.push({
+          path,
+          route: item.route,
+          ...childConfigs?.length ? { children: childConfigs } : {}
+        });
+        continue;
+      }
+      if ("layoutView" in item) {
+        const { layoutView, children, path: segment } = item;
+        assertLayoutPage(
+          layoutView,
+          `routes[{ path: "${segment}", layoutView }]`
+        );
+        if (!children?.length) {
+          throw new TypeError(
+            `Layout route "${path}" requires "children" with nested route views.`
+          );
+        }
+        result.push({
+          path,
+          route: layoutView,
+          children: walk2(children, path)
+        });
+        continue;
+      }
+      if (!isRouteViewEntry(item)) {
+        throw new TypeError(
+          `Route at "${path}" must define "routeView", "layoutView", or "route".`
+        );
+      }
+      const { routeView } = item;
+      assertPage(routeView, "createRouter");
+      const routeState = getPageState(routeView);
+      if (!routeState.view && !routeState.viewLoader) {
+        throw new TypeError(
+          `Route at "${path}" must define a view via createRouteView(), createLazyRouteView(), or createLayoutView().`
+        );
+      }
+      if (isLayoutPage(routeView)) {
+        throw new TypeError(
+          `Route "${path}": use "layoutView" instead of "routeView" for createLayoutView() instances.`
+        );
+      }
+      result.push({ path, route: routeView });
+    }
+    return result;
+  };
+  return walk2(definitions);
+};
+
+// src/core/build-named-routes.ts
+var requireEntryName = (entry, pathHint) => {
+  const name = entry.name;
+  if (!name) {
+    throw new TypeError(
+      `Route at "${pathHint}" must define "name" in createRouter({ routes }) for typed router.routes.`
+    );
+  }
+  return name;
+};
+var register = (bucket, key, route) => {
+  if (bucket[key]) {
+    throw new Error(`Duplicate route name "${key}" in createRouter({ routes }).`);
+  }
+  bucket[key] = route;
+};
+var walk = (entries, bucket, parentPath = "/") => {
+  for (const entry of entries) {
+    const pathHint = `${parentPath}${entry.path}`;
+    if ("routeView" in entry && !("layoutView" in entry)) {
+      register(bucket, requireEntryName(entry, pathHint), entry.routeView);
+      continue;
+    }
+    if ("route" in entry && !("routeView" in entry) && !("layoutView" in entry)) {
+      register(bucket, requireEntryName(entry, pathHint), entry.route);
+      if ("children" in entry && entry.children?.length) {
+        walk(entry.children, bucket, pathHint);
+      }
+      continue;
+    }
+    if ("layoutView" in entry && "children" in entry) {
+      register(bucket, requireEntryName(entry, pathHint), entry.layoutView);
+      const { children } = entry;
+      if (children?.length) {
+        walk(children, bucket, pathHint);
+      }
+    }
+  }
+};
+var buildNamedRoutes = (entries) => {
+  const bucket = {};
+  walk(entries, bucket);
+  return bucket;
+};
+
+// src/core/resolve-route-view.ts
+var emptyOutlet = () => null;
+var resolvePageLoadingView = (page) => {
+  const state = getPageState(page);
+  if (state.loadingView) return state.loadingView;
+  if (state.view) {
+    return ({ params, query }) => state.view({ params, query, outlet: emptyOutlet, data: null });
+  }
+  throw new TypeError(
+    `Route view "${page.name ?? "anonymous"}": pass loadingView or view for router loadingView.`
+  );
+};
+var resolvePageErrorView = (page) => {
+  const state = getPageState(page);
+  if (state.errorView) return state.errorView;
+  if (state.view) {
+    return ({ error, params, query }) => state.view({ params, query, outlet: emptyOutlet, data: null, error });
+  }
+  throw new TypeError(
+    `Route view "${page.name ?? "anonymous"}": pass errorView or view for router errorView.`
+  );
+};
+var resolvePageNotFoundView = (page) => {
+  const state = getPageState(page);
+  if (!state.view) {
+    throw new TypeError(
+      `Route view "${page.name ?? "anonymous"}": pass view for router notFoundView.`
+    );
+  }
+  return (context) => state.view(context);
+};
+var resolveLoadingViewOption = (option) => {
+  if (!option) return void 0;
+  if (typeof option === "function") return option;
+  return resolvePageLoadingView(option);
+};
+var resolveErrorViewOption = (option) => {
+  if (!option) return void 0;
+  if (typeof option === "function") return option;
+  return resolvePageErrorView(option);
+};
+var resolveNotFoundViewOption = (option) => {
+  if (!option) return void 0;
+  if (typeof option === "function") return option;
+  return resolvePageNotFoundView(option);
+};
+
+// src/core/router-view.ts
+var entryPage = (def) => "layoutView" in def ? def.layoutView : "routeView" in def ? def.routeView : void 0;
+var pickLoadingView = (branch, leafIndex, globalLoading) => {
+  const leaf = branch[leafIndex].page;
+  if (leaf.loadingView) return leaf.loadingView;
+  for (let i = leafIndex - 1; i >= 0; i -= 1) {
+    const candidate = branch[i].page.loadingView;
+    if (candidate) return candidate;
+  }
+  return globalLoading;
+};
+var pickErrorView = (branch, leafIndex, globalError) => {
+  const leaf = branch[leafIndex].page;
+  if (leaf.errorView) return leaf.errorView;
+  for (let i = leafIndex - 1; i >= 0; i -= 1) {
+    const candidate = branch[i].page.errorView;
+    if (candidate) return candidate;
+  }
+  return globalError;
+};
+var renderLoading = (page, branch, leafIndex, globalLoading) => {
+  const view = pickLoadingView(branch, leafIndex, globalLoading);
+  if (!view) return null;
+  const params = page.$params.value() ?? {};
+  const query = page.$query.value() ?? {};
+  return view({ params, query });
+};
+var renderError = (page, error, branch, leafIndex, globalError) => {
+  const view = pickErrorView(branch, leafIndex, globalError);
+  if (!view) return null;
+  const params = page.$params.value() ?? {};
+  const query = page.$query.value() ?? {};
+  return view({ error, params, query });
+};
+var collectChildPageNodes = (definitions) => {
+  const nodes = [];
+  for (const def of definitions) {
+    const page = entryPage(def);
+    if (!page) continue;
+    assertPage(page, "createRouter");
+    nodes.push({
+      page,
+      children: "children" in def && def.children ? collectChildPageNodes(def.children) : void 0
+    });
+  }
+  return nodes;
+};
+var collectPageRoots = (definitions) => {
+  const roots = [];
+  for (const def of definitions) {
+    const page = entryPage(def);
+    if (page) {
+      assertPage(page, "createRouter");
+      roots.push({
+        page,
+        children: "children" in def && def.children ? collectChildPageNodes(def.children) : void 0
+      });
+    } else if ("children" in def && def.children?.length) {
+      roots.push(...collectPageRoots(def.children));
+    }
+  }
+  return roots;
+};
+var findBranch = (entries, activePage) => {
+  for (const entry of entries) {
+    if (entry.page === activePage) return [entry];
+    if (entry.children?.length) {
+      const childBranch = findBranch(entry.children, activePage);
+      if (childBranch) return [entry, ...childBranch];
+    }
+  }
+  return null;
+};
+var layoutBeforeLoadFailed = (branch, leafIndex) => {
+  for (let i = 0; i < leafIndex; i += 1) {
+    const page = branch[i].page;
+    if (!isLayoutPage(page)) continue;
+    const state = getPageState(page);
+    if (state.viewLoader && !state.view) {
+      if (state.$viewPending.value() || state.$viewError.value()) return true;
+    }
+    if (resolveBeforeLoad(state) && state.$error.value()) return true;
+    if (resolveBeforeLoad(state) && state.$pending.value()) return true;
+  }
+  return false;
+};
+var renderPageView = (page, outlet, branch, leafIndex, globalLoading, globalError) => {
+  const state = getPageState(page);
+  const params = page.$params.value() ?? {};
+  const query = page.$query.value() ?? {};
+  const data = page.$data?.value() ?? null;
+  if (state.viewLoader && !state.view) {
+    if (state.$viewPending.value()) {
+      return renderLoading(page, branch, leafIndex, globalLoading) ?? null;
+    }
+    if (state.$viewError.value()) {
+      return renderError(page, state.$viewError.value(), branch, leafIndex, globalError) ?? null;
+    }
+    return renderLoading(page, branch, leafIndex, globalLoading) ?? null;
+  }
+  if (resolveBeforeLoad(state) && state.$pending.value()) {
+    return renderLoading(page, branch, leafIndex, globalLoading) ?? null;
+  }
+  if (state.$error.value()) {
+    return renderError(page, state.$error.value(), branch, leafIndex, globalError) ?? null;
+  }
+  if (!state.view) return null;
+  return state.view({ params, query, outlet, data });
+};
+var renderBranch = (branch, index, globalLoading, globalError) => {
+  const node = branch[index];
+  if (!node) return null;
+  const leafIndex = branch.length - 1;
+  if (index > 0 && layoutBeforeLoadFailed(branch, index)) {
+    return null;
+  }
+  const outlet = () => index + 1 < branch.length ? renderBranch(branch, index + 1, globalLoading, globalError) : null;
+  return renderPageView(
+    node.page,
+    outlet,
+    branch,
+    leafIndex,
+    globalLoading,
+    globalError
+  );
+};
+var createRouterViewComponent = (router, options) => {
+  const pageRoots = collectPageRoots(options.routes);
+  const globalLoading = options.loadingView;
+  const globalError = options.errorView;
+  const notFoundView = options.notFoundView;
+  return () => {
+    const activeRoutes = router.$activeRoutes.value();
+    const activePage = activeRoutes.at(-1);
+    if (!activePage || !isPage(activePage)) {
+      return notFoundView?.({ params: {}, query: {}, outlet: () => null, data: null }) ?? null;
+    }
+    const branch = findBranch(pageRoots, activePage);
+    if (!branch?.length) {
+      return notFoundView?.({ params: {}, query: {}, outlet: () => null, data: null }) ?? null;
+    }
+    return renderBranch(branch, 0, globalLoading, globalError);
+  };
+};
+
+// src/core/router.ts
+var createRouterModel = (options) => {
+  const globalLoadingView = resolveLoadingViewOption(options.loadingView);
+  const globalErrorView = resolveErrorViewOption(options.errorView);
+  const globalNotFoundView = resolveNotFoundViewOption(options.notFoundView);
+  const routeConfigs = toRouteConfigs(options.routes);
+  const flatRoutes = flattenRouteTree(routeConfigs);
+  const allRoutes = flatRoutes.map((entry) => entry.route);
+  const allPages = allRoutes.filter(isPage);
+  const $path = signal("/");
+  const $query = signal({});
+  const $fullPath = signal("/");
+  const $activeRoute = signal(null);
+  const $activeRoutes = signal([]);
+  const $params = signal({});
+  const $activePage = computed(() => {
+    const routes2 = $activeRoutes.value();
+    for (let i = routes2.length - 1; i >= 0; i -= 1) {
+      const route = routes2[i];
+      if (isPage(route)) return route;
+    }
+    return null;
+  });
+  const $matched = computed(() => [...$activeRoutes.value()]);
+  const $pending = computed(() => {
+    const page = $activePage.value();
+    return page ? getPageState(page).$pending.value() : false;
+  });
+  const $error = computed(() => {
+    const page = $activePage.value();
+    return page ? getPageState(page).$error.value() : null;
+  });
+  let started = false;
+  let unlisten = null;
+  let syncing = false;
+  let syncQueued = false;
+  let navigationId = 0;
+  const closeAllRoutes = () => {
+    cancelPageLoads(allPages);
+    for (const route of allRoutes) {
+      applyRouteClosed(getRouteState(route));
+    }
+  };
+  const routes = buildNamedRoutes(options.routes);
+  let router;
+  router = {
+    history: options.history,
+    flatRoutes,
+    options,
+    loadingView: globalLoadingView,
+    errorView: globalErrorView,
+    navigationId: 0,
+    View: (() => null),
+    $path,
+    $query,
+    $fullPath,
+    $activeRoute,
+    $activePage,
+    $activeRoutes,
+    $matched,
+    $params,
+    $pending,
+    $error,
+    routes,
+    start() {
+      if (started) return;
+      started = true;
+      for (const entry of flatRoutes) {
+        bindRouteToRouter(entry.route, router, entry.path);
+      }
+      unlisten = options.history.listen(() => {
+        router.sync();
+      });
+      router.sync();
+    },
+    stop() {
+      if (!started) return;
+      started = false;
+      unlisten?.();
+      unlisten = null;
+      closeAllRoutes();
+      $activeRoute.set(null);
+      $activeRoutes.set([]);
+      $params.set({});
+    },
+    go(path, opts) {
+      if (opts?.replace) options.history.replace(path);
+      else options.history.push(path);
+    },
+    navigate(path, opts) {
+      router.go(path, opts);
+    },
+    replace(path) {
+      options.history.replace(path);
+    },
+    back() {
+      options.history.back();
+    },
+    forward() {
+      options.history.forward();
+    },
+    reload() {
+      router.sync();
+    },
+    resolve(route, params, opts) {
+      const state = getRouteState(route);
+      if (!state.pathTemplate) {
+        throw new Error("Route is not registered in a router");
+      }
+      return buildRouteLocation(
+        state.pathTemplate,
+        params ?? {},
+        opts?.query
+      );
+    },
+    isActive(route) {
+      return $activeRoutes.value().includes(route);
+    },
+    view() {
+      return router.View;
+    },
+    closeRoute(route) {
+      if (!$activeRoutes.peek().includes(route)) return;
+      options.history.push("/");
+    },
+    sync() {
+      if (syncing) {
+        syncQueued = true;
+        return;
+      }
+      syncing = true;
+      try {
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+          const currentNavigationId = ++navigationId;
+          router.navigationId = currentNavigationId;
+          const location = options.history.getLocation();
+          const { pathname, search, query } = parseLocation(location);
+          const fullPath = search ? `${pathname}${search}` : pathname;
+          $path.set(pathname);
+          $query.set(query);
+          $fullPath.set(fullPath);
+          if (options.authorizationGuard && !runAuthorizationGuard(pathname, options.authorizationGuard, options.history)) {
+            continue;
+          }
+          const match = matchRouteChain(pathname, flatRoutes);
+          if (!match) {
+            cancelPageLoads(allPages);
+            $activeRoute.set(null);
+            $activeRoutes.set([]);
+            $params.set({});
+            closeAllRoutes();
+            return;
+          }
+          if (!runRouteGuards(options.history, match.leaf.route, query)) {
+            continue;
+          }
+          const activeSet = new Set(match.chain.map((entry) => entry.route));
+          $activeRoute.set(match.leaf.route);
+          $activeRoutes.set(match.chain.map((entry) => entry.route));
+          $params.set(match.leafParams);
+          for (const route of allRoutes) {
+            const state = getRouteState(route);
+            if (!activeSet.has(route)) {
+              applyRouteClosed(state);
+              continue;
+            }
+            const entry = match.chain.find((item) => item.route === route);
+            const entryParams = matchParamsForEntry(entry, pathname);
+            applyRouteOpened(state, {
+              params: entryParams,
+              query: rawQueryToTyped(query),
+              path: pathname,
+              fullPath
+            });
+          }
+          void runBeforeLoadChain(match.chain, pathname, query, currentNavigationId);
+          return;
+        }
+      } finally {
+        syncing = false;
+        if (syncQueued) {
+          syncQueued = false;
+          router.sync();
+        }
+      }
+    }
+  };
+  for (const entry of flatRoutes) {
+    bindRouteToRouter(entry.route, router, entry.path);
+  }
+  return Object.assign(router, {
+    View: createRouterViewComponent(router, {
+      routes: options.routes,
+      notFoundView: globalNotFoundView,
+      loadingView: globalLoadingView,
+      errorView: globalErrorView
+    })
+  });
+};
+
+// src/core/create-router.ts
+var createRouter = (options) => {
+  const { history: historyConfig, routes, ...rest } = options;
+  const history = resolveHistory(historyConfig);
+  return createRouterModel({ ...rest, history, routes });
+};
+var createRouter2 = (options) => attachRouterQueryParams(
+  createRouter(options)
+);
+var Link = (props) => {
+  const { to, href, params, query, replace, children } = props;
+  const resolvedHref = () => {
+    if (href) return href;
+    if (!to) return "#";
+    const state = getRouteState(to);
+    if (!state.router || !state.pathTemplate) return "#";
+    return state.router.resolve(to, params ?? {}, { query });
+  };
+  const onClick = (event) => {
+    if (!to) return;
+    event.preventDefault();
+    if (params !== void 0) {
+      to.go(params, { query, replace });
+    } else {
+      to.go(void 0, { query, replace });
+    }
+  };
+  return h(
+    "a",
+    {
+      href: resolvedHref,
+      onClick: to ? onClick : void 0
+    },
+    children ?? null
+  );
+};
+var NavLink = (props) => {
+  const {
+    to,
+    href,
+    params,
+    query,
+    replace,
+    children,
+    activeClass = "active",
+    class: className
+  } = props;
+  const resolvedHref = () => {
+    if (href) return href;
+    if (!to) return "#";
+    const state = getRouteState(to);
+    if (!state.router || !state.pathTemplate) return "#";
+    return state.router.resolve(to, params ?? {}, { query });
+  };
+  const classProp = () => {
+    const active = to?.$isOpened.value() ?? false;
+    return cx(className, active && activeClass);
+  };
+  const onClick = (event) => {
+    if (!to) return;
+    event.preventDefault();
+    if (params !== void 0) {
+      to.go(params, { query, replace });
+    } else {
+      to.go(void 0, { query, replace });
+    }
+  };
+  const ariaCurrent = () => to?.$isOpened.value() ? "page" : void 0;
+  return h(
+    "a",
+    {
+      href: resolvedHref,
+      class: classProp,
+      "aria-current": ariaCurrent,
+      onClick: to ? onClick : void 0
+    },
+    children ?? null
+  );
+};
+var ROUTER_KEY = /* @__PURE__ */ Symbol.for("echojs.router");
+var isRouterLike = (value) => typeof value === "object" && value !== null && typeof value.View === "function" && typeof value.start === "function";
+var createRouterProvider = (router, options = {}) => ({
+  name: "router",
+  setup(app) {
+    app.provide?.(ROUTER_KEY, router);
+  },
+  resolveRoot() {
+    if (options.autoStart !== false) {
+      router.start();
+    }
+    const RootView = createView(() => router.View, "EchoRouterRoot");
+    return RootView();
+  }
+});
+var routerPlugin = createRouterProvider;
+
+// src/core/create-routes.ts
+function createRoutes(routes) {
+  return routes;
+}
+
+// src/operators/guard.ts
+var guardRoute = (options) => registerGuard(options);
+
+// src/operators/redirect.ts
+var redirect = (options) => {
+  const { from, to, mapParams, mapQuery } = options;
+  return from.opened.subscribe((payload) => {
+    const params = mapParams ? mapParams(payload.params) : payload.params;
+    const query = mapQuery ? mapQuery(payload.query) : payload.query;
+    to.go(params, { query, replace: true });
+  });
+};
+var chainRoute = (options) => {
+  const { route, beforeOpen } = options;
+  const $isOpened = signal(false);
+  const $pending = signal(false);
+  const $error = signal(null);
+  const $params = signal(null);
+  const $query = signal({});
+  const $result = signal(null);
+  let runId = 0;
+  const reset = () => {
+    $isOpened.set(false);
+    $pending.set(false);
+    $error.set(null);
+    $params.set(null);
+    $query.set({});
+    $result.set(null);
+  };
+  route.opened.subscribe((payload) => {
+    const id = ++runId;
+    reset();
+    $pending.set(true);
+    $params.set(payload.params);
+    $query.set(payload.query);
+    Promise.resolve(beforeOpen({ params: payload.params, query: payload.query })).then((result) => {
+      if (id !== runId) return;
+      $pending.set(false);
+      $error.set(null);
+      $result.set(result);
+      $isOpened.set(true);
+    }).catch((error) => {
+      if (id !== runId) return;
+      $pending.set(false);
+      $error.set(error);
+      $isOpened.set(false);
+    });
+  });
+  route.closed.subscribe(() => {
+    runId += 1;
+    reset();
+  });
+  return {
+    $isOpened,
+    $pending,
+    $error,
+    $params,
+    $query,
+    $result
+  };
+};
+
+export { Link, NavLink, ROUTER_KEY, assertPage, buildNamedRoutes, buildPath, chainRoute, createBrowserHistory, createHashHistory, createLayoutView, createLazyRouteView, createMemoryHistory, createRoute, createRouteView, createRouter2 as createRouter, createRouter as createRouterCore, createRouterProvider, createRoutes, flattenRouteTree, guardRoute, isLayoutPage, isLazyRouteView, isPage, isRouterLike, joinLocation, joinRoutePaths, matchPath, matchRouteChain, normalizePathname, parseQuery, parseQueryValues, redirect, resolveHistory, routerPlugin, splitLocation, stringifyQuery };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map