@benjavicente/angular-router-experimental 1.142.11

package/src/injectLoaderDeps.ts

@@ -0,0 +1,45 @@
+import { injectMatch } from './injectMatch'
+import type * as Angular from '@angular/core'
+import type {
+  AnyRouter,
+  RegisteredRouter,
+  ResolveUseLoaderDeps,
+  StrictOrFrom,
+  UseLoaderDepsResult,
+} from '@benjavicente/router-core'
+
+export interface InjectLoaderDepsBaseOptions<
+  TRouter extends AnyRouter,
+  TFrom,
+  TSelected,
+> {
+  select?: (deps: ResolveUseLoaderDeps<TRouter, TFrom>) => TSelected
+}
+
+export type InjectLoaderDepsOptions<
+  TRouter extends AnyRouter,
+  TFrom extends string | undefined,
+  TSelected,
+> = StrictOrFrom<TRouter, TFrom> &
+  InjectLoaderDepsBaseOptions<TRouter, TFrom, TSelected>
+
+export type InjectLoaderDepsRoute<out TFrom> = <
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectLoaderDepsBaseOptions<TRouter, TFrom, TSelected>,
+) => Angular.Signal<UseLoaderDepsResult<TRouter, TFrom, TSelected>>
+
+export function injectLoaderDeps<
+  TRouter extends AnyRouter = RegisteredRouter,
+  const TFrom extends string | undefined = undefined,
+  TSelected = unknown,
+>(
+  opts: InjectLoaderDepsOptions<TRouter, TFrom, TSelected>,
+): Angular.Signal<UseLoaderDepsResult<TRouter, TFrom, TSelected>> {
+  const { select, ...rest } = opts
+  return injectMatch({
+    ...rest,
+    select: (s) => (select ? select(s.loaderDeps) : s.loaderDeps),
+  }) as any
+}

package/src/injectLocation.ts

@@ -0,0 +1,38 @@
+import { deepEqual } from '@benjavicente/router-core'
+import { injectRouter } from './injectRouter'
+import { injectStore } from './injectStore'
+import type {
+  AnyRouter,
+  RegisteredRouter,
+  RouterState,
+} from '@benjavicente/router-core'
+import type * as Angular from '@angular/core'
+
+export interface InjectLocationOptions<TRouter extends AnyRouter, TSelected> {
+  select?: (
+    location: RouterState<TRouter['routeTree']>['location'],
+  ) => TSelected
+}
+
+export type InjectLocationResult<
+  TRouter extends AnyRouter,
+  TSelected,
+> = unknown extends TSelected
+  ? RouterState<TRouter['routeTree']>['location']
+  : TSelected
+
+export function injectLocation<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectLocationOptions<TRouter, TSelected>,
+): Angular.Signal<InjectLocationResult<TRouter, TSelected>> {
+  const router = injectRouter<TRouter>()
+
+  return injectStore(
+    router.stores.location,
+    (location) =>
+      (opts?.select ? opts.select(location as any) : location) as any,
+    { equal: deepEqual }
+  ) as Angular.Signal<InjectLocationResult<TRouter, TSelected>>
+}

package/src/injectMatch.ts

@@ -0,0 +1,122 @@
+import * as Angular from '@angular/core'
+import { deepEqual, invariant } from '@benjavicente/router-core'
+import { MATCH_CONTEXT_INJECTOR_TOKEN } from './matchInjectorToken'
+import { injectRouter } from './injectRouter'
+import { injectStore } from './injectStore'
+import type {
+  AnyRouter,
+  MakeRouteMatch,
+  MakeRouteMatchUnion,
+  RegisteredRouter,
+  StrictOrFrom,
+  ThrowConstraint,
+  ThrowOrOptional,
+} from '@benjavicente/router-core'
+
+export interface InjectMatchBaseOptions<
+  TRouter extends AnyRouter,
+  TFrom,
+  TStrict extends boolean,
+  TThrow extends boolean,
+  TSelected,
+> {
+  select?: (
+    match: MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>,
+  ) => TSelected
+  shouldThrow?: TThrow
+}
+
+export type InjectMatchRoute<out TFrom> = <
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectMatchBaseOptions<TRouter, TFrom, true, true, TSelected>,
+) => Angular.Signal<InjectMatchResult<TRouter, TFrom, true, TSelected>>
+
+export type InjectMatchOptions<
+  TRouter extends AnyRouter,
+  TFrom,
+  TStrict extends boolean,
+  TThrow extends boolean,
+  TSelected,
+> = StrictOrFrom<TRouter, TFrom, TStrict> &
+  InjectMatchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>
+
+export type InjectMatchResult<
+  TRouter extends AnyRouter,
+  TFrom,
+  TStrict extends boolean,
+  TSelected,
+> = unknown extends TSelected
+  ? TStrict extends true
+  ? MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>
+  : MakeRouteMatchUnion<TRouter>
+  : TSelected
+
+export function injectMatch<
+  TRouter extends AnyRouter = RegisteredRouter,
+  const TFrom extends string | undefined = undefined,
+  TStrict extends boolean = true,
+  TThrow extends boolean = true,
+  TSelected = unknown,
+>(
+  opts: InjectMatchOptions<
+    TRouter,
+    TFrom,
+    TStrict,
+    ThrowConstraint<TStrict, TThrow>,
+    TSelected
+  >,
+): Angular.Signal<
+  ThrowOrOptional<InjectMatchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>
+> {
+  const router = injectRouter<TRouter>()
+  const nearestMatch = opts.from
+    ? undefined
+    : Angular.inject(MATCH_CONTEXT_INJECTOR_TOKEN)
+
+  const pendingRouteIds = injectStore(
+    router.stores.pendingRouteIds,
+    (s) => s,
+  )
+  const isTransitioning = injectStore(
+    router.stores.isTransitioning,
+    (s) => s,
+  )
+
+  const match = () => {
+    if (opts.from) {
+      return router.stores.getMatchStoreByRouteId(opts.from).state
+    }
+
+    return nearestMatch?.match()
+  }
+
+  return Angular.computed(() => {
+    const selectedMatch = match()
+
+    if (selectedMatch !== undefined) {
+      return opts.select ? opts.select(selectedMatch as any) : selectedMatch
+    }
+
+    const hasPendingMatch = opts.from
+      ? Boolean(pendingRouteIds()[opts.from])
+      : nearestMatch?.hasPending() ?? false
+
+    if (
+      !hasPendingMatch &&
+      !isTransitioning() &&
+      (opts.shouldThrow ?? true)
+    ) {
+      if (process.env.NODE_ENV !== 'production') {
+        throw new Error(
+          `Invariant failed: Could not find ${opts.from ? `an active match from "${opts.from}"` : 'a nearest match!'}`,
+        )
+      }
+
+      invariant()
+    }
+
+    return undefined
+  }, { equal: deepEqual }) as any
+}

package/src/injectMatchRoute.ts

@@ -0,0 +1,58 @@
+import * as Angular from '@angular/core'
+import { injectRouter } from './injectRouter'
+import { injectStore } from './injectStore'
+import type {
+  AnyRouter,
+  DeepPartial,
+  Expand,
+  MakeOptionalPathParams,
+  MakeOptionalSearchParams,
+  MaskOptions,
+  MatchRouteOptions,
+  NoInfer,
+  RegisteredRouter,
+  ResolveRoute,
+  ToSubOptionsProps,
+} from '@benjavicente/router-core'
+
+export type InjectMatchRouteOptions<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TFrom extends string = string,
+  TTo extends string | undefined = undefined,
+  TMaskFrom extends string = TFrom,
+  TMaskTo extends string = '',
+> = ToSubOptionsProps<TRouter, TFrom, TTo> &
+  DeepPartial<MakeOptionalSearchParams<TRouter, TFrom, TTo>> &
+  DeepPartial<MakeOptionalPathParams<TRouter, TFrom, TTo>> &
+  MaskOptions<TRouter, TMaskFrom, TMaskTo> &
+  MatchRouteOptions
+
+export function injectMatchRoute<
+  TRouter extends AnyRouter = RegisteredRouter,
+>() {
+  const router = injectRouter<TRouter>()
+  const reactivity = injectStore(router.stores.matchRouteReactivity, (d) => d)
+
+  return <
+    const TFrom extends string = string,
+    const TTo extends string | undefined = undefined,
+    const TMaskFrom extends string = TFrom,
+    const TMaskTo extends string = '',
+  >(
+    opts: InjectMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
+  ): Angular.Signal<
+    false | Expand<ResolveRoute<TRouter, TFrom, NoInfer<TTo>>['types']['allParams']>
+  > => {
+    return Angular.computed(() => {
+      reactivity()
+      const { pending, caseSensitive, fuzzy, includeSearch, ...rest } = opts
+
+      return router.matchRoute(rest as any, {
+        pending,
+        caseSensitive,
+        fuzzy,
+        includeSearch,
+      })
+    })
+  }
+}

package/src/injectMatches.ts

@@ -0,0 +1,79 @@
+import * as Angular from '@angular/core'
+import { deepEqual } from '@benjavicente/router-core'
+import { injectRouter } from './injectRouter'
+import { injectStore } from './injectStore'
+import { MATCH_CONTEXT_INJECTOR_TOKEN } from './matchInjectorToken'
+import type {
+  AnyRouter,
+  MakeRouteMatchUnion,
+  RegisteredRouter,
+} from '@benjavicente/router-core'
+
+export interface InjectMatchesBaseOptions<
+  TRouter extends AnyRouter,
+  TSelected,
+> {
+  select?: (matches: Array<MakeRouteMatchUnion<TRouter>>) => TSelected
+}
+
+export type InjectMatchesResult<
+  TRouter extends AnyRouter,
+  TSelected,
+> = unknown extends TSelected ? Array<MakeRouteMatchUnion<TRouter>> : TSelected
+
+export function injectMatches<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectMatchesBaseOptions<TRouter, TSelected>,
+): Angular.Signal<InjectMatchesResult<TRouter, TSelected>> {
+  const router = injectRouter<TRouter>()
+  const matches = injectStore(router.stores.activeMatchesSnapshot, (value) => {
+    return value as Array<MakeRouteMatchUnion<TRouter>>
+  })
+
+  return Angular.computed(() => {
+    const currentMatches = matches()
+    const result = opts?.select ? opts.select(currentMatches) : currentMatches
+    return result as InjectMatchesResult<TRouter, TSelected>
+  }, { equal: deepEqual }) as any
+}
+
+export function injectParentMatches<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectMatchesBaseOptions<TRouter, TSelected>,
+): Angular.Signal<InjectMatchesResult<TRouter, TSelected>> {
+  const nearestMatch = Angular.inject(MATCH_CONTEXT_INJECTOR_TOKEN)
+
+  return injectMatches({
+    select: (matches: Array<MakeRouteMatchUnion<TRouter>>) => {
+      const sliced = matches.slice(
+        0,
+        matches.findIndex((d) => d.id === nearestMatch.matchId()),
+      )
+
+      return opts?.select ? opts.select(sliced) : sliced
+    },
+  } as any)
+}
+
+export function injectChildMatches<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectMatchesBaseOptions<TRouter, TSelected>,
+): Angular.Signal<InjectMatchesResult<TRouter, TSelected>> {
+  const nearestMatch = Angular.inject(MATCH_CONTEXT_INJECTOR_TOKEN)
+
+  return injectMatches({
+    select: (matches: Array<MakeRouteMatchUnion<TRouter>>) => {
+      const sliced = matches.slice(
+        matches.findIndex((d) => d.id === nearestMatch.matchId()) + 1,
+      )
+
+      return opts?.select ? opts.select(sliced) : sliced
+    },
+  } as any)
+}

package/src/injectNavigate.ts

@@ -0,0 +1,24 @@
+import { injectRouter } from './injectRouter'
+import type {
+  AnyRouter,
+  FromPathOption,
+  NavigateOptions,
+  RegisteredRouter,
+  UseNavigateResult,
+} from '@benjavicente/router-core'
+
+export function injectNavigate<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TDefaultFrom extends string = string,
+>(_defaultOpts?: {
+  from?: FromPathOption<TRouter, TDefaultFrom>
+}): UseNavigateResult<TDefaultFrom> {
+  const router = injectRouter()
+
+  return ((options: NavigateOptions) => {
+    return router.navigate({
+      ...options,
+      from: options.from ?? _defaultOpts?.from,
+    })
+  }) as UseNavigateResult<TDefaultFrom>
+}

package/src/injectParams.ts

@@ -0,0 +1,71 @@
+import { injectMatch } from './injectMatch'
+import type * as Angular from '@angular/core'
+import type {
+  AnyRouter,
+  RegisteredRouter,
+  ResolveUseParams,
+  StrictOrFrom,
+  ThrowConstraint,
+  ThrowOrOptional,
+  UseParamsResult,
+} from '@benjavicente/router-core'
+
+export interface InjectParamsBaseOptions<
+  TRouter extends AnyRouter,
+  TFrom,
+  TStrict extends boolean,
+  TThrow extends boolean,
+  TSelected,
+> {
+  select?: (params: ResolveUseParams<TRouter, TFrom, TStrict>) => TSelected
+  shouldThrow?: TThrow
+}
+
+export type InjectParamsOptions<
+  TRouter extends AnyRouter,
+  TFrom extends string | undefined,
+  TStrict extends boolean,
+  TThrow extends boolean,
+  TSelected,
+> = StrictOrFrom<TRouter, TFrom, TStrict> &
+  InjectParamsBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>
+
+export type InjectParamsRoute<out TFrom> = <
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectParamsBaseOptions<
+    TRouter,
+    TFrom,
+    /* TStrict */ true,
+    /* TThrow */ true,
+    TSelected
+  >,
+) => Angular.Signal<UseParamsResult<TRouter, TFrom, true, TSelected>>
+
+export function injectParams<
+  TRouter extends AnyRouter = RegisteredRouter,
+  const TFrom extends string | undefined = undefined,
+  TStrict extends boolean = true,
+  TThrow extends boolean = true,
+  TSelected = unknown,
+>(
+  opts: InjectParamsOptions<
+    TRouter,
+    TFrom,
+    TStrict,
+    ThrowConstraint<TStrict, TThrow>,
+    TSelected
+  >,
+): Angular.Signal<
+  ThrowOrOptional<UseParamsResult<TRouter, TFrom, true, TSelected>, TThrow>
+> {
+  return injectMatch({
+    from: opts.from!,
+    strict: opts.strict,
+    shouldThrow: opts.shouldThrow,
+    select: (match: any) => {
+      return opts.select ? opts.select(match.params) : match.params
+    },
+  } as any) as Angular.Signal<any>
+}

package/src/injectRouteContext.ts

@@ -0,0 +1,31 @@
+import { injectMatch } from './injectMatch'
+import type * as Angular from '@angular/core'
+import type {
+  AnyRouter,
+  RegisteredRouter,
+  UseRouteContextBaseOptions,
+  UseRouteContextOptions,
+  UseRouteContextResult,
+} from '@benjavicente/router-core'
+
+export type InjectRouteContextRoute<out TFrom> = <
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: UseRouteContextBaseOptions<TRouter, TFrom, true, TSelected>,
+) => Angular.Signal<UseRouteContextResult<TRouter, TFrom, true, TSelected>>
+
+export function injectRouteContext<
+  TRouter extends AnyRouter = RegisteredRouter,
+  const TFrom extends string | undefined = undefined,
+  TStrict extends boolean = true,
+  TSelected = unknown,
+>(
+  opts: UseRouteContextOptions<TRouter, TFrom, TStrict, TSelected>,
+): Angular.Signal<UseRouteContextResult<TRouter, TFrom, TStrict, TSelected>> {
+  return injectMatch({
+    ...(opts as any),
+    select: (match) =>
+      opts.select ? opts.select(match.context) : match.context,
+  }) as any
+}

package/src/injectRouter.ts

@@ -0,0 +1,17 @@
+import * as Angular from '@angular/core'
+import { getRouterInjectionKey } from './routerInjectionToken'
+import type { AnyRouter, RegisteredRouter } from '@benjavicente/router-core'
+
+export function injectRouter<
+  TRouter extends AnyRouter = RegisteredRouter,
+>(opts?: { warn?: boolean }): TRouter {
+  const router = Angular.inject(getRouterInjectionKey(), { optional: true })
+  if (process.env.NODE_ENV !== 'production') {
+    if ((opts?.warn ?? true) && !router) {
+      console.warn(
+        'Warning: injectRouter must be used inside a <router-provider> component!',
+      )
+    }
+  }
+  return router as any
+}

package/src/injectRouterState.ts

@@ -0,0 +1,53 @@
+import { isServer } from '@benjavicente/router-core/isServer'
+import * as Angular from '@angular/core'
+import { deepEqual } from '@benjavicente/router-core'
+import { injectRouter } from './injectRouter'
+import { injectStore } from './injectStore'
+import type {
+  AnyRouter,
+  RegisteredRouter,
+  RouterState,
+} from '@benjavicente/router-core'
+
+export type InjectRouterStateOptions<TRouter extends AnyRouter, TSelected> = {
+  router?: TRouter
+  select?: (state: RouterState<TRouter['routeTree']>) => TSelected
+}
+
+export type InjectRouterStateResult<
+  TRouter extends AnyRouter,
+  TSelected,
+> = unknown extends TSelected ? RouterState<TRouter['routeTree']> : TSelected
+
+export function injectRouterState<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectRouterStateOptions<TRouter, TSelected>,
+): Angular.Signal<InjectRouterStateResult<TRouter, TSelected>> {
+  const contextRouter = injectRouter({
+    warn: opts?.router === undefined,
+  })
+  const router = opts?.router ?? contextRouter
+  const state = injectStore(router.stores.__store, (state) => state)
+
+  // During SSR we render exactly once and do not need reactivity.
+  // Avoid subscribing to the store on the server since the server store
+  // implementation does not provide subscribe() semantics.
+  const _isServer =
+    typeof isServer === 'boolean' ? isServer : router.isServer
+  if (_isServer) {
+    const state = router.stores.__store.state as RouterState<
+      TRouter['routeTree']
+    >
+    const selected = (
+      opts?.select ? opts.select(state) : state
+    ) as InjectRouterStateResult<TRouter, TSelected>
+    return (() => selected) as Angular.Signal<InjectRouterStateResult<TRouter, TSelected>>
+  }
+
+  return Angular.computed(() => {
+    const result = opts?.select ? opts.select(state()) : state()
+    return result as InjectRouterStateResult<TRouter, TSelected>
+  }, { equal: deepEqual }) as any;
+}

package/src/injectSearch.ts

@@ -0,0 +1,71 @@
+import { injectMatch } from './injectMatch'
+import type * as Angular from '@angular/core'
+import type {
+  AnyRouter,
+  RegisteredRouter,
+  ResolveUseSearch,
+  StrictOrFrom,
+  ThrowConstraint,
+  ThrowOrOptional,
+  UseSearchResult,
+} from '@benjavicente/router-core'
+
+export interface InjectSearchBaseOptions<
+  TRouter extends AnyRouter,
+  TFrom,
+  TStrict extends boolean,
+  TThrow extends boolean,
+  TSelected,
+> {
+  select?: (state: ResolveUseSearch<TRouter, TFrom, TStrict>) => TSelected
+  shouldThrow?: TThrow
+}
+
+export type InjectSearchOptions<
+  TRouter extends AnyRouter,
+  TFrom,
+  TStrict extends boolean,
+  TThrow extends boolean,
+  TSelected,
+> = StrictOrFrom<TRouter, TFrom, TStrict> &
+  InjectSearchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>
+
+export type InjectSearchRoute<out TFrom> = <
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectSearchBaseOptions<
+    TRouter,
+    TFrom,
+    /* TStrict */ true,
+    /* TThrow */ true,
+    TSelected
+  >,
+) => Angular.Signal<UseSearchResult<TRouter, TFrom, true, TSelected>>
+
+export function injectSearch<
+  TRouter extends AnyRouter = RegisteredRouter,
+  const TFrom extends string | undefined = undefined,
+  TStrict extends boolean = true,
+  TThrow extends boolean = true,
+  TSelected = unknown,
+>(
+  opts: InjectSearchOptions<
+    TRouter,
+    TFrom,
+    TStrict,
+    ThrowConstraint<TStrict, TThrow>,
+    TSelected
+  >,
+): Angular.Signal<
+  ThrowOrOptional<UseSearchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>
+> {
+  return injectMatch({
+    from: opts.from!,
+    strict: opts.strict,
+    shouldThrow: opts.shouldThrow,
+    select: (match: any) => {
+      return opts.select ? opts.select(match.search) : match.search
+    },
+  } as any) as any
+}