@qwik.dev/router 2.0.0-beta.35 → 2.0.0-beta.37

package/lib/chunks/deepFreeze.qwik.mjs

@@ -1,3 +1,593 @@
+import { _getAsyncLocalStorage, _resolveContextWithoutSequentialScope, _getContextEvent, _injectAsyncSignalValue, _UNINITIALIZED, _deserialize, createAsyncQrl, SerializerSymbol, _getContextContainer, _verifySerializable } from '@qwik.dev/core/internal';
+import { createContextId, implicit$FirstArg, isServer as isServer$1, inlinedQrl, _captures, isDev } from '@qwik.dev/core';
+import * as qwikRouterConfig from '@qwik-router-config';
+import { isServer } from '@qwik.dev/core/build';
+import { g as getLoaderName } from './request-path.mjs';
+import { e as ensureSlash } from './pathname.mjs';
+
+let _asyncRequestStore;
+if (isServer) {
+  const AsyncLocalStorage = _getAsyncLocalStorage();
+  if (AsyncLocalStorage) {
+    _asyncRequestStore = new AsyncLocalStorage();
+  } else {
+    console.warn("\n=====================\n  Qwik Router Warning:\n    AsyncLocalStorage is not available, continuing without it.\n    This impacts concurrent async server calls, where they lose access to the ServerRequestEv object.\n=====================\n\n");
+  }
+}
+
+class AbortMessage {
+}
+class RedirectMessage extends AbortMessage {
+}
+
+class ServerError extends Error {
+  status;
+  data;
+  constructor(status, data) {
+    super(typeof data === "string" ? data : void 0), this.status = status, this.data = data;
+  }
+}
+
+const QACTION_KEY = "qaction";
+const QFN_KEY = "qfunc";
+const QDATA_KEY = "qdata";
+const Q_ROUTE = "q:route";
+const DEFAULT_LOADERS_SERIALIZATION_STRATEGY = globalThis.__DEFAULT_LOADERS_SERIALIZATION_STRATEGY__ || "never";
+
+const RouteStateContext = /* @__PURE__ */ createContextId("qr-s");
+const RouteLoaderCtxContext = /* @__PURE__ */ createContextId("qr-lc");
+const ContentContext = /* @__PURE__ */ createContextId("qr-c");
+const ContentInternalContext = /* @__PURE__ */ createContextId("qr-ic");
+const DocumentHeadContext = /* @__PURE__ */ createContextId("qr-h");
+const RouteLocationContext = /* @__PURE__ */ createContextId("qr-l");
+const RouteNavigateContext = /* @__PURE__ */ createContextId("qr-n");
+const RouteActionContext = /* @__PURE__ */ createContextId("qr-a");
+const RoutePreventNavigateContext = /* @__PURE__ */ createContextId("qr-p");
+const HttpStatusContext = /* @__PURE__ */ createContextId("qr-hs");
+
+const REQUEST_LOADER_PATHS_STORE = "@loaderPathsStore";
+const REQUEST_ROUTE_LOADERS = "@routeLoaders";
+const REQUEST_ROUTE_LOADER_PROMISES = "@routeLoaderPromises";
+const REQUEST_ROUTE_LOADER_EVENTS = "@routeLoaderEvents";
+const REQUEST_ROUTE_LOADER_ROOT_EVENT = "@routeLoaderRootEvent";
+const ROUTE_LOADER_VALUE_PREFIX = "__qwik_route_loader_value__";
+const FULLPATH_HEADER = "X-Qwik-fullpath";
+const LOADER_FETCH_CACHE_TTL = 5e3;
+const LOADER_FETCH_CACHE_MAX = 128;
+const fetchCache = /* @__PURE__ */ new Map();
+const perfNow = () => globalThis.performance?.now() ?? Date.now();
+const isRedirectStatus = (status) => status >= 300 && status < 400;
+const setCache = (key, entry) => {
+  fetchCache.set(key, entry);
+  if (fetchCache.size > LOADER_FETCH_CACHE_MAX) {
+    const oldestKey = fetchCache.keys().next().value;
+    if (oldestKey !== void 0) {
+      fetchCache.delete(oldestKey);
+    }
+  }
+};
+const wrapWithAbort = (promise, signal) => {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, {
+      once: true
+    });
+    promise.finally(() => signal.removeEventListener("abort", abort)).then(resolve, reject);
+  });
+};
+const getRouteLoaderValueStateKey = (loaderId) => `${ROUTE_LOADER_VALUE_PREFIX}${loaderId}`;
+const isRequestEvent = (value) => !!value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "sharedMap") && Object.prototype.hasOwnProperty.call(value, "cookie");
+const isLoaderInternal = (value) => typeof value === "function" && value.__brand === "server_loader";
+const getClientManifestHash = (ctx) => {
+  const container = ctx.$signal$?.$container$;
+  return container?.qManifestHash || _getContextContainer()?.qManifestHash || "dev";
+};
+const fetchRouteLoaderData = async (loaderId, routePath, manifestHash, opts) => {
+  if (!routePath) {
+    return void 0;
+  }
+  let resolvedPath = routePath;
+  const basePath = opts?.basePath ?? "/";
+  if (basePath !== "/" && !resolvedPath.startsWith(basePath)) {
+    resolvedPath = basePath + resolvedPath.slice(1);
+  }
+  const pathBase = ensureSlash(resolvedPath);
+  const pageUrl = opts?.pageUrl;
+  const search = pageUrl?.search ?? "";
+  const url = `${pathBase}${getLoaderName(loaderId, manifestHash)}${search}`;
+  const headers = {};
+  if (pageUrl && pageUrl.pathname !== pathBase && !globalThis.__STRICT_LOADERS__) {
+    headers[FULLPATH_HEADER] = pageUrl.pathname;
+  }
+  const cacheKey = `${url}
+${headers[FULLPATH_HEADER] ?? ""}`;
+  if (!opts?.ignoreCache) {
+    const entry = fetchCache.get(cacheKey);
+    if (entry) {
+      if (entry.promise) {
+        return opts?.signal ? wrapWithAbort(entry.promise, opts.signal) : entry.promise;
+      }
+      if (entry.expires > perfNow()) {
+        return entry.value;
+      }
+      fetchCache.delete(cacheKey);
+    }
+  }
+  const request = async () => {
+    const response = await fetch(url, {
+      signal: opts?.signal,
+      cache: opts?.ignoreCache ? "reload" : "default",
+      headers
+    });
+    if (response.redirected) {
+      return {
+        r: response.url
+      };
+    }
+    if (isRedirectStatus(response.status)) {
+      const location1 = response.headers.get("Location");
+      if (location1) {
+        return {
+          r: location1
+        };
+      }
+    }
+    if (!response.ok) {
+      return void 0;
+    }
+    const text = await response.text();
+    return _deserialize(text) ?? void 0;
+  };
+  if (opts?.ignoreCache || opts?.signal) {
+    return request();
+  }
+  const promise = request().then((value) => {
+    if (value === void 0) {
+      fetchCache.delete(cacheKey);
+    } else {
+      setCache(cacheKey, {
+        value,
+        expires: perfNow() + LOADER_FETCH_CACHE_TTL
+      });
+    }
+    return value;
+  }, (err) => {
+    fetchCache.delete(cacheKey);
+    throw err;
+  });
+  setCache(cacheKey, {
+    promise,
+    expires: perfNow() + LOADER_FETCH_CACHE_TTL
+  });
+  return promise;
+};
+const filterSearchParams = (params, allowed) => {
+  const filtered = new URLSearchParams();
+  for (let i = 0; i < allowed.length; i++) {
+    const name = allowed[i];
+    const values = params.getAll(name);
+    for (let j = 0; j < values.length; j++) {
+      filtered.append(name, values[j]);
+    }
+  }
+  filtered.sort();
+  return filtered.toString() ? `?${filtered.toString()}` : "";
+};
+const getLoaderOptions = (rest) => {
+  let serializationStrategy = DEFAULT_LOADERS_SERIALIZATION_STRATEGY;
+  let expires;
+  let poll;
+  let eTag;
+  let cacheKey;
+  let search;
+  let allowStale = true;
+  const validators = [];
+  if (rest.length === 1) {
+    const options = rest[0];
+    if (options && typeof options === "object") {
+      if ("validate" in options) {
+        validators.push(options);
+      } else {
+        if (options.serializationStrategy) {
+          serializationStrategy = options.serializationStrategy;
+        }
+        if (options.validation) {
+          validators.push(...options.validation);
+        }
+        if ("expires" in options) {
+          expires = options.expires;
+        }
+        if ("poll" in options) {
+          poll = options.poll;
+        }
+        if ("eTag" in options) {
+          eTag = options.eTag;
+        }
+        if ("cacheKey" in options) {
+          cacheKey = options.cacheKey;
+        }
+        if (options.search) {
+          search = options.search;
+        } else if (globalThis.__STRICT_LOADERS__) {
+          search = [];
+        }
+        if (options.allowStale === false) {
+          allowStale = false;
+        }
+      }
+    }
+  } else if (rest.length > 1) {
+    validators.push(...rest.filter(Boolean));
+  }
+  return {
+    validators: validators.reverse(),
+    serializationStrategy,
+    expires,
+    poll,
+    eTag,
+    cacheKey,
+    search,
+    allowStale
+  };
+};
+const getRequestEvent = (thisArg) => {
+  if (!isServer$1) {
+    throw new Error("getRequestEvent() can only be used on the server.");
+  }
+  const requestEvent = _asyncRequestStore?.getStore() || [
+    thisArg,
+    _getContextEvent()
+  ].find(isRequestEvent);
+  if (!requestEvent) {
+    throw new Error("Unable to determine the current RequestEvent.");
+  }
+  return requestEvent;
+};
+const REQUEST_ROUTE_LOADER_VALUES = "@routeLoaderValues";
+function getRouteLoaderValues(requestEv) {
+  let values = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_VALUES);
+  if (!values) {
+    values = {};
+    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_VALUES, values);
+  }
+  return values;
+}
+function getRouteLoaderPromises(requestEv) {
+  let promises = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_PROMISES);
+  if (!promises) {
+    promises = {};
+    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_PROMISES, promises);
+  }
+  return promises;
+}
+function setRouteLoaders(requestEv, loaders) {
+  requestEv.sharedMap.set(REQUEST_ROUTE_LOADERS, loaders);
+}
+function getRouteLoaders(requestEv) {
+  return requestEv.sharedMap.get(REQUEST_ROUTE_LOADERS) ?? [];
+}
+function getRouteLoaderCtx(requestEv) {
+  let ctx = requestEv.sharedMap.get(REQUEST_LOADER_PATHS_STORE);
+  if (!ctx) {
+    ctx = {
+      loaderPaths: {}
+    };
+    requestEv.sharedMap.set(REQUEST_LOADER_PATHS_STORE, ctx);
+  }
+  return ctx;
+}
+const updateRouteLoaderPaths = (ctx, loaderPaths, pageUrl) => {
+  if (!isServer$1) {
+    ctx.pagePathname = pageUrl.pathname;
+    ctx.pageSearch = pageUrl.search;
+  }
+  if (loaderPaths) {
+    for (const key in loaderPaths) {
+      ctx.loaderPaths[key] = loaderPaths[key];
+    }
+  }
+};
+const getModuleRouteLoaders = (mods) => {
+  const routeLoaders = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < mods.length; i++) {
+    const mod = mods[i];
+    if (!mod) {
+      continue;
+    }
+    for (const key in mod) {
+      const value = mod[key];
+      if (isLoaderInternal(value) && !seen.has(value.__id)) {
+        seen.add(value.__id);
+        routeLoaders.push(value);
+      }
+    }
+  }
+  return routeLoaders;
+};
+const setLoaderSignalValue = (signal, value) => {
+  _injectAsyncSignalValue(signal, value);
+};
+const resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
+  return routeLoaders.find((loader) => loader.__id === loaderId);
+};
+const getLoaderRequestEvent = (loader, requestEv) => {
+  let rootRequestEv = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+  if (!rootRequestEv) {
+    rootRequestEv = requestEv;
+    requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_ROOT_EVENT, rootRequestEv);
+  }
+  const url = new URL(rootRequestEv.url);
+  const pathname = globalThis.__STRICT_LOADERS__ ? getRouteLoaderCtx(rootRequestEv).loaderPaths[loader.__id] || rootRequestEv.url.pathname : rootRequestEv.url.pathname;
+  const filteredSearch = loader.__search ? filterSearchParams(url.searchParams, loader.__search) : rootRequestEv.url.search;
+  if (pathname === rootRequestEv.url.pathname && filteredSearch === rootRequestEv.url.search) {
+    return rootRequestEv;
+  }
+  let events = rootRequestEv.sharedMap.get(REQUEST_ROUTE_LOADER_EVENTS);
+  if (!events) {
+    events = /* @__PURE__ */ new Map();
+    rootRequestEv.sharedMap.set(REQUEST_ROUTE_LOADER_EVENTS, events);
+  }
+  const eventKey = `${pathname}
+${filteredSearch}`;
+  let loaderRequestEv = events.get(eventKey);
+  if (!loaderRequestEv) {
+    url.pathname = pathname;
+    url.search = filteredSearch;
+    loaderRequestEv = Object.create(rootRequestEv, {
+      pathname: {
+        get: () => url.pathname,
+        enumerable: true
+      },
+      query: {
+        get: () => url.searchParams,
+        enumerable: true
+      },
+      url: {
+        value: url,
+        enumerable: true
+      }
+    });
+    events.set(eventKey, loaderRequestEv);
+  }
+  return loaderRequestEv;
+};
+async function runValidators(requestEv, validators, data) {
+  let lastResult = {
+    success: true,
+    data
+  };
+  if (validators) {
+    for (let i = 0; i < validators.length; i++) {
+      const validator = validators[i];
+      lastResult = await validator.validate(requestEv, data);
+      if (!lastResult.success) {
+        return lastResult;
+      }
+      data = lastResult.data;
+    }
+  }
+  return lastResult;
+}
+function verifySerializable(data, qrl) {
+  try {
+    _verifySerializable(data, void 0);
+  } catch (error) {
+    if (error instanceof Error && qrl.dev) {
+      error.loc = qrl.dev;
+    }
+    throw error;
+  }
+}
+const getRouteLoaderData = async (loaderQrl, validators, requestEv) => {
+  const loaderRequestEv = requestEv;
+  const result = await runValidators(requestEv, validators, void 0);
+  if (!result.success) {
+    return loaderRequestEv.fail(result.status ?? 500, result.error);
+  }
+  const resolved = await loaderQrl.call(loaderRequestEv, loaderRequestEv);
+  const value = typeof resolved === "function" ? resolved() : resolved;
+  if (isDev) {
+    verifySerializable(value, loaderQrl);
+  }
+  return value;
+};
+const loadRouteLoaderByQrl = (loaderId, loaderQrl, validators, requestEv) => {
+  const values = getRouteLoaderValues(requestEv);
+  if (loaderId in values) {
+    return Promise.resolve(values[loaderId]);
+  }
+  const promises = getRouteLoaderPromises(requestEv);
+  let promise = promises[loaderId];
+  if (!promise) {
+    promise = getRouteLoaderData(loaderQrl, validators, requestEv).then((value) => {
+      values[loaderId] = value;
+      return value;
+    }, (err) => {
+      delete promises[loaderId];
+      throw err;
+    });
+    promises[loaderId] = promise;
+  }
+  return promise;
+};
+class ServerRouteLoaderCapture {
+  hash;
+  qrl;
+  validators;
+  constructor(hash, qrl, validators) {
+    this.hash = hash;
+    this.qrl = qrl;
+    this.validators = validators;
+  }
+  load() {
+    const requestEv = getRequestEvent();
+    const values = getRouteLoaderValues(requestEv);
+    if (this.hash in values) {
+      return values[this.hash];
+    }
+    return loadRouteLoaderByQrl(this.hash, this.qrl, this.validators, requestEv);
+  }
+  [SerializerSymbol]() {
+    return this.hash;
+  }
+}
+const createRouteLoaderSignal = (loader, routeLoaderCtx, state) => {
+  const id = loader.__id;
+  const stateValues = state;
+  const resumeValueKey = getRouteLoaderValueStateKey(id);
+  const capture = isServer$1 ? new ServerRouteLoaderCapture(id, loader.__qrl, loader.__validators) : id;
+  const searchFilter = loader.__search;
+  const lastFetch = {};
+  return createAsyncQrl(/* @__PURE__ */ inlinedQrl(async (ctx) => {
+    const capture2 = _captures[0], id2 = _captures[1], lastFetch2 = _captures[2], resumeValueKey2 = _captures[3], routeLoaderCtx2 = _captures[4], searchFilter2 = _captures[5], stateValues2 = _captures[6];
+    if (ctx.info && typeof ctx.info === "object" && "__v" in ctx.info) {
+      const value = ctx.info.__v;
+      if (!isServer$1 && resumeValueKey2 in stateValues2) {
+        stateValues2[resumeValueKey2] = value;
+      }
+      return value;
+    }
+    if (isServer$1) {
+      return capture2.load();
+    }
+    const routePath = ctx.track(routeLoaderCtx2.loaderPaths, id2);
+    const pagePathname = ctx.track(routeLoaderCtx2, "pagePathname") || location.pathname;
+    const pageSearch = ctx.track(routeLoaderCtx2, "pageSearch") || location.search;
+    const pageUrl = new URL(pagePathname + pageSearch, location.href);
+    const mHash = getClientManifestHash(ctx);
+    const basePath = qwikRouterConfig.basePathname ?? "/";
+    const needsResumeFetch = stateValues2[resumeValueKey2] === _UNINITIALIZED;
+    const fetchRoutePath = routePath || (needsResumeFetch ? pageUrl.pathname : void 0);
+    if (!fetchRoutePath) {
+      return ctx.previous;
+    }
+    let fetchUrl = pageUrl;
+    if (searchFilter2) {
+      const filteredSearch = filterSearchParams(pageUrl.searchParams, searchFilter2);
+      if (ctx.previous !== void 0 && filteredSearch === lastFetch2.filteredSearch && fetchRoutePath === lastFetch2.routePath) {
+        return ctx.previous;
+      }
+      lastFetch2.filteredSearch = filteredSearch;
+      lastFetch2.routePath = fetchRoutePath;
+      fetchUrl = new URL(pageUrl.href);
+      fetchUrl.search = filteredSearch;
+    }
+    const response = await fetchRouteLoaderData(id2, fetchRoutePath, mHash, {
+      pageUrl: fetchUrl,
+      basePath,
+      ignoreCache: ctx.info === true,
+      signal: ctx.abortSignal
+    });
+    if (!response) {
+      throw new Error(`Loader ${id2} returned empty response`);
+    }
+    if (response.r) {
+      const goto = routeLoaderCtx2.goto;
+      if (goto) {
+        goto(response.r, {
+          replaceState: true
+        });
+      } else {
+        location.href = response.r;
+      }
+      return ctx.previous;
+    }
+    if (response.e) {
+      throw response.e;
+    }
+    if (needsResumeFetch) {
+      stateValues2[resumeValueKey2] = response.d;
+    }
+    return response.d;
+  }, "createRouteLoaderSignal_createAsync_0vpftJHSMyo", [
+    capture,
+    id,
+    lastFetch,
+    resumeValueKey,
+    routeLoaderCtx,
+    searchFilter,
+    stateValues
+  ]), {
+    serializationStrategy: loader.__serializationStrategy,
+    expires: loader.__expires,
+    poll: loader.__poll,
+    allowStale: loader.__allowStale
+  });
+};
+const ensureRouteLoaderSignal = (loader, state, routeLoaderCtx) => {
+  if (isServer$1 && loader.__serializationStrategy === "never") {
+    state[getRouteLoaderValueStateKey(loader.__id)] = _UNINITIALIZED;
+  }
+  return state[loader.__id] ||= createRouteLoaderSignal(loader, routeLoaderCtx, state);
+};
+const ensureRouteLoaderSignals = (mods, state, routeLoaderCtx) => {
+  const loaders = getModuleRouteLoaders(mods);
+  for (let i = 0; i < loaders.length; i++) {
+    const loader = loaders[i];
+    ensureRouteLoaderSignal(loader, state, routeLoaderCtx);
+  }
+  return loaders;
+};
+const loadRouteLoader = (loader, requestEv) => loadRouteLoaderByQrl(loader.__id, loader.__qrl, loader.__validators, getLoaderRequestEvent(loader, requestEv));
+const getRouteLoaderResponse = async (loaderQrl, validators, requestEv) => {
+  try {
+    const value = await getRouteLoaderData(loaderQrl, validators, requestEv);
+    if (value && typeof value === "object" && value.failed) {
+      return {
+        e: new ServerError(requestEv.status(), value)
+      };
+    }
+    return {
+      d: value
+    };
+  } catch (err) {
+    if (err instanceof RedirectMessage) {
+      const location1 = requestEv.headers.get("Location") || "/";
+      requestEv.headers.delete("Location");
+      return {
+        r: location1
+      };
+    }
+    if (err instanceof ServerError) {
+      return {
+        e: err
+      };
+    }
+    throw err;
+  }
+};
+const routeLoaderQrl = (loaderQrl, ...rest) => {
+  const { validators, serializationStrategy, expires, poll, eTag, cacheKey, search, allowStale } = getLoaderOptions(rest);
+  function loader() {
+    const state = _resolveContextWithoutSequentialScope(RouteStateContext);
+    let signal = state[loader.__id];
+    if (!signal) {
+      const routeLoaderCtx = _resolveContextWithoutSequentialScope(RouteLoaderCtxContext);
+      signal = ensureRouteLoaderSignal(loader, state, routeLoaderCtx);
+    }
+    void signal.promise();
+    return signal;
+  }
+  loader.__brand = "server_loader";
+  loader.__qrl = loaderQrl;
+  loader.__validators = validators;
+  loader.__id = loaderQrl.getHash();
+  loader.__serializationStrategy = serializationStrategy;
+  loader.__expires = expires ?? 12e4;
+  loader.__poll = poll ?? false;
+  loader.__eTag = eTag;
+  loader.__cacheKey = cacheKey;
+  loader.__search = search;
+  loader.__allowStale = allowStale;
+  Object.freeze(loader);
+  return loader;
+};
+const routeLoader$ = /* @__PURE__ */ implicit$FirstArg(routeLoaderQrl);
+
 const deepFreeze = (obj) => {
   if (obj == null) {
     return obj;
@@ -15,4 +605,4 @@ const deepFreeze = (obj) => {
   return Object.freeze(obj);
 };
 
-export { deepFreeze as d };
+export { AbortMessage as A, ContentContext as C, DocumentHeadContext as D, FULLPATH_HEADER as F, HttpStatusContext as H, QACTION_KEY as Q, RouteLocationContext as R, ServerError as S, _asyncRequestStore as _, ContentInternalContext as a, RouteNavigateContext as b, RouteStateContext as c, RouteLoaderCtxContext as d, ensureRouteLoaderSignals as e, fetchRouteLoaderData as f, RouteActionContext as g, RoutePreventNavigateContext as h, Q_ROUTE as i, getRequestEvent as j, QFN_KEY as k, QDATA_KEY as l, routeLoaderQrl as m, getRouteLoaderCtx as n, getRouteLoaderValues as o, loadRouteLoader as p, setRouteLoaders as q, routeLoader$ as r, setLoaderSignalValue as s, RedirectMessage as t, updateRouteLoaderPaths as u, deepFreeze as v, getRouteLoaders as w, getLoaderRequestEvent as x, resolveRouteLoaderByHash as y, getRouteLoaderResponse as z };

package/lib/chunks/format.mjs

@@ -0,0 +1,31 @@
+function toTitleCase(str) {
+  return str.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase();
+  });
+}
+function addError(ctx, e) {
+  ctx.diagnostics.push({
+    type: "error",
+    message: e ? String(e.stack || e) : "Error"
+  });
+}
+function addWarning(ctx, message) {
+  ctx.diagnostics.push({
+    type: "warn",
+    message: String(message)
+  });
+}
+function msToString(ms) {
+  if (ms < 1) {
+    return ms.toFixed(2) + " ms";
+  }
+  if (ms < 1e3) {
+    return ms.toFixed(1) + " ms";
+  }
+  if (ms < 6e4) {
+    return (ms / 1e3).toFixed(1) + " s";
+  }
+  return (ms / 6e4).toFixed(1) + " m";
+}
+
+export { addError as a, addWarning as b, msToString as m, toTitleCase as t };

package/lib/chunks/fs.mjs

@@ -1,5 +1,6 @@
 import { normalize, basename, dirname, relative } from 'node:path';
-import { t as toTitleCase, n as normalizePathname } from './pathname.mjs';
+import { t as toTitleCase } from './format.mjs';
+import { n as normalizePathname, e as ensureSlash } from './pathname.mjs';
 
 function parseRouteIndexName(extlessName) {
   let layoutName = "";
@@ -56,11 +57,8 @@ function normalizePath(path) {
 function getMenuPathname(opts, filePath) {
   let pathname = normalizePath(relative(opts.routesDir, filePath));
   pathname = `/` + normalizePath(dirname(pathname));
-  let result = normalizePathname(pathname, opts.basePathname);
-  if (!result.endsWith("/")) {
-    result += "/";
-  }
-  return result;
+  const result = normalizePathname(pathname, opts.basePathname);
+  return ensureSlash(result);
 }
 function createFileId(routesDir, fsPath, explicitFileType) {
   const ids = [];