@solidjs/router 2.0.0-next.30 → 2.0.0-next.32

package/dist/routers/factory.jsx

@@ -1,5 +1,5 @@
 /*@refresh skip*/
-import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, sharedConfig, untrack } from "solid-js";
+import { createSignal, getOwner, onCleanup, onSettled, runWithOwner, untrack } from "solid-js";
 // standalone imports: `DEV` is undefined in solid's production build and
 // `OBSERVE` outside its observe/dev builds, so app bundlers fold the
 // `DEV &&` diagnostics and the `OBSERVE &&` attribution out of shipped bundles
@@ -53,7 +53,6 @@ function describeNavigation(match, next, written, from) {
         const t = to();
         return t === undefined ? undefined : new URL(t, mockBase).pathname;
     };
-    const matches = (pathname) => untrack(() => match(pathname));
     const ref = {
         kind: "navigation",
         get to() {
@@ -61,22 +60,61 @@ function describeNavigation(match, next, written, from) {
         },
         from,
         get name() {
-            const p = pathname();
-            if (p === undefined)
-                return undefined;
-            const m = matches(p);
-            return m.length ? m[m.length - 1].route.pattern || "/" : p;
+            return routeName(match, pathname());
         },
         get params() {
-            const p = pathname();
-            const m = p === undefined ? [] : matches(p);
-            return m.length ? mergeParams(m) : undefined;
+            return routeParams(match, pathname());
         }
     };
     if (next._navigation !== undefined && next._navigation > 1)
         ref.redirect = next._navigation - 1;
     return ref;
 }
+/** The parametrized route `pathname` matches — the last match's pattern, `/` for the root; the pathname itself when nothing matched. */
+function routeName(match, pathname) {
+    if (pathname === undefined)
+        return undefined;
+    const m = untrack(() => match(pathname));
+    return m.length ? m[m.length - 1].route.pattern || "/" : pathname;
+}
+/** The params the matched chain bound, merged; `undefined` when nothing matched. */
+function routeParams(match, pathname) {
+    if (pathname === undefined)
+        return undefined;
+    const m = untrack(() => match(pathname));
+    return m.length ? mergeParams(m) : undefined;
+}
+/**
+ * The route the document arrived on, for solid's observe tier: the same
+ * declaration as a navigation's, around the work that establishes the
+ * router's initial match — building its context — since a fresh document has
+ * no location write to wrap. On the client the engine opens it at the time
+ * origin and settles it as the context is built (the first `"navigation"`
+ * record, `initial: true`); on the server the same call names the request's
+ * `"render"` record (`RenderEvent.route`). Every field is a getter read at
+ * settle, as for a navigation: `to` is the location as the router then holds
+ * it — the arrival normalized onto the base path when it came in empty, a
+ * write the frame itself took (see the setter) — and `name`/`params` match
+ * it then, so a lazy subtree that resolved while the server rendered names
+ * the exact route.
+ */
+function describeInitial(match, location) {
+    const to = () => untrack(location).value;
+    const pathname = () => new URL(to(), mockBase).pathname;
+    return {
+        kind: "navigation",
+        initial: true,
+        get to() {
+            return to();
+        },
+        get name() {
+            return routeName(match, pathname());
+        },
+        get params() {
+            return routeParams(match, pathname());
+        }
+    };
+}
 /** Wraps a history adapter in the integration signal the router core consumes. Must run under a reactive owner. */
 function createIntegration(history, match) {
     let committing = false;
@@ -91,8 +129,6 @@ function createIntegration(history, match) {
     const signal = [
         read,
         (next) => {
-            if (sharedConfig.registry && !sharedConfig.done)
-                sharedConfig.done = true;
             // What the write resolved to, or undefined when there was nothing to
             // write (see `resolveLocationWrite`).
             let written;
@@ -128,8 +164,15 @@ function createIntegration(history, match) {
             // while a navigation is pending, which is the `from` a hop wants too.
             // A write the no-op rule drops is still declared: the engine settles a
             // navigation whose write "did not survive the equality gate" on the spot.
-            OBSERVE
-                ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, untrack(read).value), commit)
+            // A write from NO location is not a navigation: it is the arrival being
+            // normalized (`createRouterContext` moving an empty location — a hash
+            // history with no hash, a memory history seeded with "" — onto the base
+            // path), and the arrival is already declared by the initial frame open
+            // around the context build (`describeInitial`), which this write then
+            // stamps. The location is never empty again after that first write.
+            const from = untrack(read).value;
+            OBSERVE && from
+                ? OBSERVE.attribution.withOrigin(describeNavigation(match, next, () => written, from), commit)
                 : commit();
         }
     ];
@@ -210,11 +253,16 @@ export function createRouter(config) {
             ? staticIntegration(props.url, config.history && config.history.utils)
             : createIntegration(history || browserHistory(), matchPath);
         let context;
-        const routerState = createRouterContext(integration, branches, () => context, {
+        const buildContext = () => createRouterContext(integration, branches, () => context, {
             base: basePath,
             singleFlight: config.singleFlight,
             transformUrl: config.transformUrl
         });
+        // The route the document arrived on, declared around the initial match
+        // (see `describeInitial`); folded out of shipped bundles with `OBSERVE`.
+        const routerState = OBSERVE
+            ? OBSERVE.attribution.withOrigin(describeInitial(matchPath, integration.signal[0]), buildContext)
+            : buildContext();
         if (!isServer) {
             setupNativeEvents({
                 preload: config.preloadLinks,
@@ -247,9 +295,8 @@ export function createRouter(config) {
             }));
         },
         keysFor(url) {
-            const pathname = typeof url === "string" ? new URL(url, mockBase).pathname : url[HREF];
             const keys = [];
-            for (const { route } of matchPath(pathname)) {
+            for (const { route } of matchPath(pathnameOf(url))) {
                 const key = serverRouteOf(route.component)?.call?.key;
                 typeof key === "string" && key && !keys.includes(key) && keys.push(key);
             }

package/dist/routers/history.js

@@ -9,10 +9,11 @@ export function bindEvent(target, type, handler) {
 // guard machinery itself lives behind the lazy `beforeLeave` slot.
 let depth;
 export function saveCurrentDepth() {
-    if (!window.history.state || window.history.state._depth == null) {
-        window.history.replaceState({ ...window.history.state, _depth: window.history.length - 1 }, "");
+    const h = window.history;
+    if (!h.state || h.state._depth == null) {
+        h.replaceState({ ...h.state, _depth: h.length - 1 }, "");
     }
-    depth = window.history.state._depth;
+    depth = h.state?._depth ?? h.length - 1;
 }
 function keepDepth(state) {
     return {
@@ -50,15 +51,10 @@ function scrollToHash(hash, fallbackTop) {
 }
 export function browserHistory() {
     const getSource = () => {
-        const url = window.location.pathname + window.location.search;
-        const state = window.history.state &&
-            window.history.state._depth &&
-            Object.keys(window.history.state).length === 1
-            ? undefined
-            : window.history.state;
+        const s = window.history.state;
         return {
-            value: url + window.location.hash,
-            state
+            value: window.location.pathname + window.location.search + window.location.hash,
+            state: s && s._depth && Object.keys(s).length === 1 ? undefined : s
         };
     };
     const beforeLeave = {};

package/dist/routers/scrollRestoration.js

@@ -105,8 +105,7 @@ export function createScrollRestoration() {
             // reload/back_forward document loads land on an existing entry (a fresh
             // navigation starts a new one and belongs at the top); the effect's
             // initial run performs the restore after first render
-            const [nav] = (performance.getEntriesByType &&
-                performance.getEntriesByType("navigation"));
+            const [nav] = performance.getEntriesByType?.("navigation");
             if (nav && nav.type !== "navigate")
                 pending = depth();
         }

package/dist/routing.js

@@ -391,9 +391,7 @@ export function createRoutes(routeDef, base = "") {
             let pattern = isLeaf ? path : path.split("/*", 1)[0];
             pattern = pattern
                 .split("/")
-                .map((s) => {
-                return s.startsWith(":") || s.startsWith("*") ? s : encodeSegment(s);
-            })
+                .map(s => (/^[:*]/.test(s) ? s : encodeSegment(s)))
                 .join("/");
             acc.push({
                 ...shared,
@@ -487,13 +485,12 @@ export function mergeParams(matches) {
     return params;
 }
 function createLocation(path, state, queryWrapper) {
-    const origin = new URL(mockBase);
-    const url = createMemo((prev = origin) => {
+    const url = createMemo((prev = new URL(mockBase)) => {
         const path_ = path();
         try {
             // anchor rooted paths against the origin explicitly - a path with
             // doubled leading slashes would otherwise parse as protocol-relative
-            return new URL(path_[0] === "/" ? mockBase + path_ : path_, origin);
+            return new URL(path_[0] === "/" ? mockBase + path_ : path_, mockBase);
         }
         catch (err) {
             DEV && console.error(`Invalid path ${path_}`);
@@ -505,8 +502,8 @@ function createLocation(path, state, queryWrapper) {
     const pathname = createMemo(() => url().pathname);
     const search = createMemo(() => url().search);
     const hash = createMemo(() => url().hash);
-    const key = () => "";
-    const queryFn = createMemo(() => extractSearchParams(url()));
+    // Pathname and hash changes do not affect the query.
+    const queryFn = createMemo(() => extractSearchParams(new URL(search(), mockBase)));
     return {
         get pathname() {
             return pathname();
@@ -521,7 +518,7 @@ function createLocation(path, state, queryWrapper) {
             return state();
         },
         get key() {
-            return key();
+            return "";
         },
         query: queryWrapper ? queryWrapper(queryFn) : createMemoObject(queryFn)
     };
@@ -660,7 +657,7 @@ export function createRouterContext(integration, branches, getContext, options =
             read = runWithOwner(routerOwner, () => createMemo(() => {
                 const result = resolveLazySubtree(record);
                 return result instanceof Promise ? result.then(() => undefined) : undefined;
-            }, { name: "lazyRoutes" }));
+            }, DEV && { name: "lazyRoutes" }));
             lazyReaders.set(record, read);
         }
         return read();
@@ -695,7 +692,7 @@ export function createRouterContext(integration, branches, getContext, options =
             }
         }
         return m;
-    }, { name: "matches" });
+    }, DEV && { name: "matches" });
     const routingPending = createMemo(() => isPending(() => {
         try {
             matches();
@@ -706,7 +703,7 @@ export function createRouterContext(integration, branches, getContext, options =
         }
         location.search;
         location.hash;
-    }), { name: "routingPending" });
+    }), DEV && { name: "routingPending" });
     const isRouting = () => routingPending() || isPending(source);
     const transitionIntent = () => {
         if (!isPending(source))
@@ -912,10 +909,8 @@ export function createRouterContext(integration, branches, getContext, options =
         preloadIntent = "preload";
         for (let match in next) {
             const { route, params } = next[match];
-            route.component &&
-                route.component.preload &&
-                route.component.preload();
             const { preload, component } = route;
+            component?.preload?.();
             const now = current && current[match];
             const unchanged = now &&
                 now.route.key === route.key &&
@@ -978,9 +973,7 @@ export function createRouteContext(router, parent, outlet, match, matches = () =
     // its last valid value while this route is being torn down, so outgoing
     // components and preloads never observe another route's params.
     const params = wrapParams(() => mergeParams(matches()));
-    component &&
-        component.preload &&
-        component.preload();
+    component?.preload?.();
     inPreloadFn = true;
     const data = preload
         ? preload({ params, location, intent: router.intent?.() || "initial" })

package/dist/utils.js

@@ -43,7 +43,7 @@ export function validateSearch(schema, raw) {
     return outcome;
 }
 export function extractSearchParams(url) {
-    const params = {};
+    const params = Object.create(null);
     url.searchParams.forEach((value, key) => {
         if (key in params) {
             if (Array.isArray(params[key]))
@@ -54,7 +54,8 @@ export function extractSearchParams(url) {
         else
             params[key] = value;
     });
-    return params;
+    // Keep __proto__ as an own property on the plain object returned to callers.
+    return { ...params };
 }
 export function createMatcher(path, partial, matchFilters) {
     const [pattern, splat] = path.split("/*", 2);
@@ -78,13 +79,13 @@ export function createMatcher(path, partial, matchFilters) {
             path: len ? "" : "/",
             params: {}
         };
-        const matchFilter = (s) => matchFilters === undefined ? undefined : matchFilters[s];
+        const filters = matchFilters;
         for (let i = 0; i < len; i++) {
             const segment = segments[i];
             const dynamic = segment[0] === ":";
             const locSegment = dynamic ? locSegments[i] : locSegments[i].toLowerCase();
             const key = dynamic ? segment.slice(1) : segment.toLowerCase();
-            if (dynamic && matchSegment(locSegment, matchFilter(key))) {
+            if (dynamic && matchSegment(locSegment, filters?.[key])) {
                 match.params[key] = locSegment;
             }
             else if (dynamic || !matchSegment(locSegment, key)) {
@@ -94,7 +95,7 @@ export function createMatcher(path, partial, matchFilters) {
         }
         if (splat) {
             const remainder = lenDiff ? locSegments.slice(-lenDiff).join("/") : "";
-            if (matchSegment(remainder, matchFilter(splat))) {
+            if (matchSegment(remainder, filters?.[splat])) {
                 match.params[splat] = remainder;
             }
             else {
@@ -104,25 +105,15 @@ export function createMatcher(path, partial, matchFilters) {
         return match;
     };
 }
-function matchSegment(input, filter) {
-    const isEqual = (s) => s === input;
-    if (filter === undefined) {
-        return true;
-    }
-    else if (typeof filter === "string") {
-        return isEqual(filter);
-    }
-    else if (typeof filter === "function") {
-        return filter(input);
-    }
-    else if (Array.isArray(filter)) {
-        return filter.some(isEqual);
-    }
-    else if (filter instanceof RegExp) {
-        return filter.test(input);
-    }
-    return false;
-}
+// a string filter is the segment itself; anything else not listed never matches
+const matchSegment = (input, filter) => filter === undefined ||
+    (typeof filter === "function"
+        ? filter(input)
+        : Array.isArray(filter)
+            ? filter.includes(input)
+            : filter instanceof RegExp
+                ? filter.test(input)
+                : filter === input);
 export function scoreRoute(route) {
     const [pattern, splat] = route.pattern.split("/*", 2);
     const segments = pattern.split("/").filter(Boolean);

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.30",
+  "version": "2.0.0-next.32",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -38,22 +38,22 @@
     "@rollup/plugin-node-resolve": "15.3.0",
     "@rollup/plugin-terser": "0.4.4",
     "@solidjs/vite-plugin": "3.0.0-next.35",
-    "@solidjs/web": "^2.0.0-rc.9",
+    "@solidjs/web": "^2.0.0-rc.13",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.0",
     "babel-preset-solid": "^2.0.0-rc.2",
     "jsdom": "^25.0.1",
     "prettier": "^3.4.1",
     "rollup": "^4.27.4",
-    "solid-js": "^2.0.0-rc.9",
+    "solid-js": "^2.0.0-rc.13",
     "typescript": "^5.7.2",
     "vite": "^8.2.2",
     "vitest": "^4.1.11"
   },
   "peerDependencies": {
-    "@solidjs/web": "^2.0.0-rc.9",
+    "@solidjs/web": "^2.0.0-rc.13",
     "filesystem-routing": ">=0.4.0",
-    "solid-js": "^2.0.0-rc.9"
+    "solid-js": "^2.0.0-rc.13"
   },
   "peerDependenciesMeta": {
     "filesystem-routing": {