Result

Kind: Type

Source: src/router.ts

Type representing the result of a route match.

The result can be in one of two formats:

1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
2. An array of handlers with their corresponding parameter maps.

Example:

[[handler, paramIndexMap][], paramArray]

typescript
[
  [
    [middlewareA, {}],                     // '*'
    [funcA,       {'id': 0}],              // '/user/:id/*'
    [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
  ],
  ['123', 'abc']
]

[[handler, params][]]

typescript
[
  [
    [middlewareA, {}],                             // '*'
    [funcA,       {'id': '123'}],                  // '/user/:id/*'
    [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
  ]
]

Result represents the output of a route match in the router. It associates matched handlers with either parameter index maps plus a shared parameter array, or with parameter maps containing resolved parameter values.

Definition

ts
[[T, ParamIndexMap][], ParamStash] | [[T, Params][]]

Diagram

mermaid
graph LR
  Match[Route match] --> Result[Result]
  Result --> Indexed[Handler/index-map pairs + parameter stash]
  Result --> Resolved[Handler/resolved-params pairs]
  Indexed --> Handlers[Handler entries]
  Indexed --> Stash[Parameter array]
  Resolved --> Params[Parameter maps]

Usage

ts
import type { Result } from './router'

const result: Result = [
  [
    [middlewareA, {}],
    [funcA, { id: 0 }],
    [funcB, { id: 0, action: 1 }],
  ],
  ['123', 'abc'],
]

// Resolve an indexed parameter map for a matched handler.
const [, paramIndexes] = result[0][1]
const params = Object.fromEntries(
  Object.entries(paramIndexes).map(([name, index]) => [
    name,
    result[1][index],
  ])
)

// params is { id: '123' }

AI Coding Instructions

• Preserve the handler ordering in Result; handlers run in route-match order.
• When working with the indexed format, read parameter values from the shared parameter stash using each map's index.
• Do not treat index-map values as parameter values; they point into the parameter array.
• Support the resolved format when consuming match results, where parameter maps already contain string values.
• Keep handler and parameter-map entries paired when transforming route match results.