@solidjs/router 2.0.0-next.35 → 2.0.0-next.36

package/dist/data/action.js

@@ -209,7 +209,10 @@ function installRouterIntegrations() {
 }
 export function useSubmissions(fn, filter) {
     const router = useRouter();
-    const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))));
+    // Submissions are immutable records, so the same records in the same order
+    // are the same list: another action's submissions changing re-runs the
+    // filter but must not re-run this list's readers.
+    const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))), { equals: (a, b) => a.length === b.length && a.every((s, i) => s === b[i]) });
     return new Proxy([], {
         get(_, property) {
             if (property === $TRACK)

package/dist/index.js

@@ -544,6 +544,14 @@ const int = s => /^-?\d+$/.test(s);
  * untyped, definitionally.
  */
 
+/**
+ * Sibling routes that share a param prefix (`/posts/:id`, `/posts/:id/edit`)
+ * each contribute a call at that node, and a call on an intersection of
+ * function types resolves to its first overload only. So the call reads its
+ * result back through `this` — the whole intersection — where the
+ * continuations of every sibling with the same arity have merged.
+ */
+
 /**
  * The type of a router instance's `paths` proxy for a given route tree.
  * Requires the tree to be a literal tuple (`as const` or a `const` type
@@ -3349,7 +3357,12 @@ function installRouterIntegrations() {
 }
 function useSubmissions(fn, filter) {
   const router = useRouter();
-  const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))));
+  // Submissions are immutable records, so the same records in the same order
+  // are the same list: another action's submissions changing re-runs the
+  // filter but must not re-run this list's readers.
+  const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))), {
+    equals: (a, b) => a.length === b.length && a.every((s, i) => s === b[i])
+  });
   return new Proxy([], {
     get(_, property) {
       if (property === $TRACK) return subs();

package/dist/paths.d.ts

@@ -82,9 +82,29 @@ type TuplePaths<R extends readonly unknown[], PAcc extends Params> = R extends r
     ...infer T extends readonly unknown[]
 ] ? RouteContrib<H, PAcc> & TuplePaths<T, PAcc> : {};
 type PathLeaf<Sch extends SearchTypes, C, PAcc extends Params> = PathEnd<Sch, Flat<PAcc>> & ChildPaths<C, PAcc>;
-type PathNode<Segs extends readonly string[], F, Sch extends SearchTypes, C, PAcc extends Params> = Segs extends readonly [infer H extends string, ...infer R extends readonly string[]] ? H extends `:${infer N}?` ? ((arg: ParamArg<N, F>) => PathNode<R, F, Sch, C, PAcc & {
+declare const PARAM_NEXT: unique symbol;
+/**
+ * Sibling routes that share a param prefix (`/posts/:id`, `/posts/:id/edit`)
+ * each contribute a call at that node, and a call on an intersection of
+ * function types resolves to its first overload only. So the call reads its
+ * result back through `this` — the whole intersection — where the
+ * continuations of every sibling with the same arity have merged.
+ */
+interface ParamCall<A extends readonly unknown[]> {
+    (...args: A): this extends {
+        readonly [PARAM_NEXT]: {
+            [K in A["length"]]: infer N;
+        };
+    } ? N : never;
+}
+type ParamCallTo<A extends readonly unknown[], N> = ParamCall<A> & {
+    readonly [PARAM_NEXT]: {
+        [K in A["length"]]: N;
+    };
+};
+type PathNode<Segs extends readonly string[], F, Sch extends SearchTypes, C, PAcc extends Params> = Segs extends readonly [infer H extends string, ...infer R extends readonly string[]] ? H extends `:${infer N}?` ? ParamCallTo<[ParamArg<N, F>], PathNode<R, F, Sch, C, PAcc & {
     [K in N]?: string;
-}>) & PathNode<R, F, Sch, C, PAcc & {
+}>> & PathNode<R, F, Sch, C, PAcc & {
     [K in N]?: string;
 }> : H extends `:${string}` | `*${string}` ? ParamCallNode<Segs, F, Sch, C, PAcc> : {
     [K in H]: PathNode<R, F, Sch, C, PAcc>;
@@ -93,7 +113,7 @@ type ParamCallNode<Segs extends readonly string[], F, Sch extends SearchTypes, C
     args: infer A extends readonly unknown[];
     params: infer P2 extends Params;
     rest: infer R2 extends readonly string[];
-} ? ((...args: A) => PathNode<R2, F, Sch, C, PAcc & P2>) & (R2 extends readonly [] ? {
+} ? ParamCallTo<A, PathNode<R2, F, Sch, C, PAcc & P2>> & (R2 extends readonly [] ? {
     (...args: [...A, Sch["input"], string?]): string;
 } : {}) & TypedPath<Flat<PAcc & P2>> : never;
 type RouteContrib<Def, PAcc extends Params> = Def extends {

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "2.0.0-next.35",
+  "version": "2.0.0-next.36",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",