route-pattern: explicit aliases for legitimate uses of any

Author: pcattori

packages/route-pattern/src/lib/href.ts

@@ -1,6 +1,7 @@
 import type { RequiredParams, OptionalParams } from './params.ts'
 import { parse, type ParseResult, type Token } from './parse.ts'
 import type { RoutePattern } from './route-pattern.ts'
+import type { UnknownArgs } from './type-utils.ts'
 import type { Variant } from './variant.ts'
 
 /**
@@ -28,7 +29,7 @@ export class MissingParamError extends Error {
  * @return A function that builds hrefs from patterns and parameters
  */
 export function createHrefBuilder<T extends string | RoutePattern = string>(): HrefBuilder<T> {
-  return (pattern: string | RoutePattern, ...args: any) =>
+  return (pattern: string | RoutePattern, ...args: UnknownArgs) =>
     formatHref(parse(typeof pattern === 'string' ? pattern : pattern.source), ...args)
 }
 

packages/route-pattern/src/lib/parse.ts

@@ -1,5 +1,6 @@
 import { split, type SplitPattern, type Split } from './split.ts'
 import { parseSearchConstraints, type SearchConstraints } from './search-constraints.ts'
+import type { ForceDistributive } from './type-utils.ts'
 
 /**
  * An error thrown when a pattern fails to parse.
@@ -176,7 +177,7 @@ export interface ParsedPattern {
 
 // prettier-ignore
 export type Parse<T extends string> =
-  T extends any ?
+  T extends ForceDistributive ?
     Split<T> extends infer S extends SplitPattern ?
       {
         protocol: S['protocol'] extends string ? ParsePart<S['protocol']> : undefined

packages/route-pattern/src/lib/type-utils.ts

@@ -4,3 +4,34 @@ export type IsEqual<A, B> =
   (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false
 
 export type Simplify<T> = { [K in keyof T]: T[K] } & {}
+
+/**
+ * Function arguments are contravariant, so unknown args must be typed as `Array<any>`
+ *
+ * Usage:
+ *
+ * ```ts
+ * type UnknownFunction = (args: UnknownArgs) => unknown
+ * ```
+ */
+export type UnknownArgs = Array<any>
+
+/**
+ * Force TS to distribute a union with `T extends ForceDistributeUnion ? ... : ...`
+ * as a more explicit alias of the common `T extends any ? ... : ...` pattern.
+ *
+ * See: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+ *
+ * Usage:
+ *
+ * ```ts
+ * type Stuff<T> =
+ *   T extends ForceDistributive ?
+ *     // Now, operate on each member of the union separately
+ *     string extends T ? 'string' :
+ *     T
+ *   :
+ *   never
+ * ```
+ */
+export type ForceDistributive = any