@benjavicente/angular-router-experimental 1.142.11

package/src/fileRoute.ts

@@ -0,0 +1,232 @@
+import { createRoute } from './route'
+
+import { injectMatch } from './injectMatch'
+import { injectLoaderDeps } from './injectLoaderDeps'
+import { injectLoaderData } from './injectLoaderData'
+import { injectSearch } from './injectSearch'
+import { injectParams } from './injectParams'
+import { injectNavigate } from './injectNavigate'
+import { injectRouter } from './injectRouter'
+import { injectRouteContext } from './injectRouteContext'
+import type { InjectParamsRoute } from './injectParams'
+import type { InjectMatchRoute } from './injectMatch'
+import type { InjectSearchRoute } from './injectSearch'
+import type {
+  AnyContext,
+  AnyRoute,
+  AnyRouter,
+  ConstrainLiteral,
+  FileBaseRouteOptions,
+  FileRoutesByPath,
+  LazyRouteOptions,
+  Register,
+  RegisteredRouter,
+  ResolveParams,
+  Route,
+  RouteById,
+  RouteConstraints,
+  RouteIds,
+  UpdatableRouteOptions,
+  UseNavigateResult,
+} from '@benjavicente/router-core'
+import type { InjectLoaderDepsRoute } from './injectLoaderDeps'
+import type { InjectLoaderDataRoute } from './injectLoaderData'
+import type { InjectRouteContextRoute } from './injectRouteContext'
+
+export function createFileRoute<
+  TFilePath extends keyof FileRoutesByPath,
+  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],
+  TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],
+  TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],
+  TFullPath extends
+  RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath'],
+>(
+  path?: TFilePath,
+): InternalFileRouteFactory<
+  TFilePath,
+  TParentRoute,
+  TId,
+  TPath,
+  TFullPath
+>['createRoute'] {
+  if (typeof path === 'object') {
+    return new InternalFileRouteFactory<
+      TFilePath,
+      TParentRoute,
+      TId,
+      TPath,
+      TFullPath
+    >().createRoute(path) as any
+  }
+  return new InternalFileRouteFactory<
+    TFilePath,
+    TParentRoute,
+    TId,
+    TPath,
+    TFullPath
+  >().createRoute
+}
+
+class InternalFileRouteFactory<
+  TFilePath extends keyof FileRoutesByPath,
+  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],
+  TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],
+  TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],
+  TFullPath extends
+  RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath'],
+> {
+  createRoute = <
+    TRegister = Register,
+    TSearchValidator = undefined,
+    TParams = ResolveParams<TPath>,
+    TRouteContextFn = AnyContext,
+    TBeforeLoadFn = AnyContext,
+    TLoaderDeps extends Record<string, any> = {},
+    TLoaderFn = undefined,
+    TChildren = unknown,
+    TSSR = unknown,
+    TMiddlewares = unknown,
+    THandlers = undefined,
+  >(
+    options?: FileBaseRouteOptions<
+      TRegister,
+      TParentRoute,
+      TId,
+      TPath,
+      TSearchValidator,
+      TParams,
+      TLoaderDeps,
+      TLoaderFn,
+      AnyContext,
+      TRouteContextFn,
+      TBeforeLoadFn,
+      AnyContext,
+      TSSR,
+      TMiddlewares,
+      THandlers
+    > &
+      UpdatableRouteOptions<
+        TParentRoute,
+        TId,
+        TFullPath,
+        TParams,
+        TSearchValidator,
+        TLoaderFn,
+        TLoaderDeps,
+        AnyContext,
+        TRouteContextFn,
+        TBeforeLoadFn
+      >,
+  ): Route<
+    TRegister,
+    TParentRoute,
+    TPath,
+    TFullPath,
+    TFilePath,
+    TId,
+    TSearchValidator,
+    TParams,
+    AnyContext,
+    TRouteContextFn,
+    TBeforeLoadFn,
+    TLoaderDeps,
+    TLoaderFn,
+    TChildren,
+    unknown,
+    TSSR,
+    TMiddlewares,
+    THandlers
+  > => {
+    const route = createRoute(options as any)
+      ; (route as any).isRoot = false
+    return route as any
+  }
+}
+
+declare module '@benjavicente/router-core' {
+  export interface LazyRoute<in out TRoute extends AnyRoute> {
+    injectMatch: InjectMatchRoute<TRoute['id']>
+    injectRouteContext: InjectRouteContextRoute<TRoute['id']>
+    injectSearch: InjectSearchRoute<TRoute['id']>
+    injectParams: InjectParamsRoute<TRoute['id']>
+    injectLoaderDeps: InjectLoaderDepsRoute<TRoute['id']>
+    injectLoaderData: InjectLoaderDataRoute<TRoute['id']>
+    injectNavigate: () => UseNavigateResult<TRoute['fullPath']>
+  }
+}
+
+export class LazyRoute<TRoute extends AnyRoute> {
+  options: {
+    id: string
+  } & LazyRouteOptions
+
+  constructor(
+    opts: {
+      id: string
+    } & LazyRouteOptions,
+  ) {
+    this.options = opts
+  }
+
+  injectMatch: InjectMatchRoute<TRoute['id']> = (opts) => {
+    return injectMatch({
+      select: opts?.select,
+      from: this.options.id,
+    } as any) as any
+  }
+
+  injectRouteContext: InjectRouteContextRoute<TRoute['id']> = (opts) => {
+    return injectRouteContext({ ...(opts as any), from: this.options.id }) as any
+  }
+
+  injectSearch: InjectSearchRoute<TRoute['id']> = (opts) => {
+    return injectSearch({
+      select: opts?.select,
+      from: this.options.id,
+    } as any) as any
+  }
+
+  injectParams: InjectParamsRoute<TRoute['id']> = (opts) => {
+    return injectParams({
+      select: opts?.select,
+      from: this.options.id,
+    } as any) as any
+  }
+
+  injectLoaderDeps: InjectLoaderDepsRoute<TRoute['id']> = (opts) => {
+    return injectLoaderDeps({ ...opts, from: this.options.id } as any)
+  }
+
+  injectLoaderData: InjectLoaderDataRoute<TRoute['id']> = (opts) => {
+    return injectLoaderData({ ...opts, from: this.options.id } as any)
+  }
+
+  injectNavigate = (): UseNavigateResult<TRoute['fullPath']> => {
+    const router = injectRouter()
+    return injectNavigate({ from: router.routesById[this.options.id].fullPath })
+  }
+}
+
+export function createLazyRoute<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TId extends string = string,
+  TRoute extends AnyRoute = RouteById<TRouter['routeTree'], TId>,
+>(id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>) {
+  return (opts: LazyRouteOptions) => {
+    return new LazyRoute<TRoute>({
+      id: id,
+      ...opts,
+    })
+  }
+}
+
+export function createLazyFileRoute<
+  TFilePath extends keyof FileRoutesByPath,
+  TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],
+>(id: TFilePath): (opts: LazyRouteOptions) => LazyRoute<TRoute> {
+  if (typeof id === 'object') {
+    return new LazyRoute<TRoute>(id) as any
+  }
+
+  return (opts: LazyRouteOptions) => new LazyRoute<TRoute>({ id, ...opts })
+}

package/src/index.ts

@@ -0,0 +1,173 @@
+// Router
+export {
+  createRouter,
+  Router,
+  type AngularInjectFn,
+  type AngularRouterContext,
+} from './router'
+
+// Route creation
+export {
+  createRoute,
+  createRootRoute,
+  createRootRouteWithContext,
+  createRouteMask,
+  getRouteApi,
+  Route,
+  RootRoute,
+  NotFoundRoute,
+  RouteApi,
+  type AnyRootRoute,
+  type RouteComponent,
+  type ErrorRouteComponent,
+  type NotFoundRouteComponent,
+} from './route'
+
+export {
+  createFileRoute,
+  LazyRoute,
+  createLazyRoute,
+  createLazyFileRoute,
+} from './fileRoute'
+
+// Router Provider
+export { RouterProvider, provideTanstackRouter } from './RouterProvider'
+export {
+  provideHeadContent,
+  provideTanstackDocument,
+  provideTanstackDocumentTitle,
+  provideTanstackHeadManagedTags,
+  provideTanstackBodyManagedTags,
+  type TanstackDocumentFeatures,
+  buildMatchManagedDocumentContent,
+  buildManagedDocumentContent,
+} from './document'
+
+// Components
+export { Outlet, RouteMatch } from './Match'
+export { Matches } from './Matches'
+export { injectSsrScrollRestorationScript } from './ssr-scroll-restoration'
+export {
+  injectMatches,
+  injectParentMatches,
+  injectChildMatches,
+  type InjectMatchesBaseOptions,
+  type InjectMatchesResult,
+} from './injectMatches'
+export { injectMatchRoute, type InjectMatchRouteOptions } from './injectMatchRoute'
+
+// Injection functions
+export { injectRouter } from './injectRouter'
+
+export {
+  injectRouterState,
+  type InjectRouterStateOptions,
+  type InjectRouterStateResult,
+} from './injectRouterState'
+
+export { injectNavigate } from './injectNavigate'
+
+export {
+  injectMatch,
+  type InjectMatchOptions,
+  type InjectMatchResult,
+  type InjectMatchRoute,
+  type InjectMatchBaseOptions,
+} from './injectMatch'
+
+export {
+  injectParams,
+  type InjectParamsOptions,
+  type InjectParamsRoute,
+  type InjectParamsBaseOptions,
+} from './injectParams'
+
+export {
+  injectSearch,
+  type InjectSearchOptions,
+  type InjectSearchRoute,
+  type InjectSearchBaseOptions,
+} from './injectSearch'
+
+export {
+  injectLoaderData,
+  type InjectLoaderDataOptions,
+  type InjectLoaderDataRoute,
+  type InjectLoaderDataBaseOptions,
+} from './injectLoaderData'
+
+export {
+  injectLoaderDeps,
+  type InjectLoaderDepsOptions,
+  type InjectLoaderDepsRoute,
+  type InjectLoaderDepsBaseOptions,
+} from './injectLoaderDeps'
+
+export {
+  injectRouteContext,
+  type InjectRouteContextRoute,
+} from './injectRouteContext'
+
+export {
+  injectLocation,
+  type InjectLocationOptions,
+  type InjectLocationResult,
+} from './injectLocation'
+
+export {
+  injectBlocker,
+  type InjectBlockerOpts,
+  type UseBlockerOpts,
+  type ShouldBlockFn,
+} from './injectBlocker'
+
+export { injectCanGoBack } from './injectCanGoBack'
+
+export { injectErrorState } from './injectErrorState'
+
+export { injectStore } from './injectStore'
+
+// Link
+export { type LinkOptions as LinkInputOptions, Link } from './Link'
+
+// Core re-exports
+export {
+  lazyFn,
+  notFound,
+  redirect,
+  isRedirect,
+  retainSearchParams,
+  createRouterConfig,
+} from '@benjavicente/router-core'
+
+// History utilities
+export {
+  createHistory,
+  createBrowserHistory,
+  createHashHistory,
+  createMemoryHistory,
+} from '@benjavicente/history'
+
+export type {
+  BlockerFn,
+  HistoryLocation,
+  RouterHistory,
+  ParsedPath,
+  HistoryState,
+} from '@benjavicente/history'
+
+// Re-export types from router-core that are commonly used (FileRoutesByPath augmented by routeTree.gen.ts via declare module '@benjavicente/router-core')
+export type {
+  AnyRouter,
+  RegisteredRouter,
+  RouterState,
+  LinkOptions,
+  NavigateOptions,
+  RouteOptions,
+  RootRouteOptions,
+  Register,
+  RouterContextOptions,
+  FileRoutesByPath,
+  CreateFileRoute,
+  CreateLazyFileRoute,
+} from '@benjavicente/router-core'

package/src/injectBlocker.ts

@@ -0,0 +1,196 @@
+import * as Angular from '@angular/core'
+import { injectRouter } from './injectRouter'
+import type {
+  BlockerFnArgs,
+  HistoryAction,
+  HistoryLocation,
+} from '@benjavicente/history'
+import type {
+  AnyRoute,
+  AnyRouter,
+  ParseRoute,
+  RegisteredRouter,
+} from '@benjavicente/router-core'
+
+interface ShouldBlockFnLocation<
+  out TRouteId,
+  out TFullPath,
+  out TAllParams,
+  out TFullSearchSchema,
+> {
+  routeId: TRouteId
+  fullPath: TFullPath
+  pathname: string
+  params: TAllParams
+  search: TFullSearchSchema
+}
+
+type AnyShouldBlockFnLocation = ShouldBlockFnLocation<any, any, any, any>
+
+type MakeShouldBlockFnLocationUnion<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>,
+> = TRoute extends any
+  ? ShouldBlockFnLocation<
+      TRoute['id'],
+      TRoute['fullPath'],
+      TRoute['types']['allParams'],
+      TRoute['types']['fullSearchSchema']
+    >
+  : never
+
+type BlockerResolver<TRouter extends AnyRouter = RegisteredRouter> =
+  | {
+      status: 'blocked'
+      current: MakeShouldBlockFnLocationUnion<TRouter>
+      next: MakeShouldBlockFnLocationUnion<TRouter>
+      action: HistoryAction
+      proceed: () => void
+      reset: () => void
+    }
+  | {
+      status: 'idle'
+      current: undefined
+      next: undefined
+      action: undefined
+      proceed: undefined
+      reset: undefined
+    }
+
+type ShouldBlockFnArgs<TRouter extends AnyRouter = RegisteredRouter> = {
+  current: MakeShouldBlockFnLocationUnion<TRouter>
+  next: MakeShouldBlockFnLocationUnion<TRouter>
+  action: HistoryAction
+}
+
+export type ShouldBlockFn<TRouter extends AnyRouter = RegisteredRouter> = (
+  args: ShouldBlockFnArgs<TRouter>,
+) => boolean | Promise<boolean>
+
+export type UseBlockerOpts<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TWithResolver extends boolean = boolean,
+> = {
+  shouldBlockFn: ShouldBlockFn<TRouter>
+  enableBeforeUnload?: boolean | (() => boolean)
+  disabled?: boolean
+  withResolver?: TWithResolver
+}
+
+export type InjectBlockerOpts<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TWithResolver extends boolean = boolean,
+> = {
+  shouldBlockFn: ShouldBlockFn<TRouter>
+  enableBeforeUnload?: boolean | (() => boolean)
+  disabled?: boolean | (() => boolean)
+  withResolver?: TWithResolver
+}
+
+export function injectBlocker<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TWithResolver extends boolean = boolean,
+>(
+  opts: InjectBlockerOpts<TRouter, TWithResolver>,
+): TWithResolver extends true
+  ? Angular.Signal<BlockerResolver<TRouter>>
+  : void {
+  const {
+    shouldBlockFn,
+    enableBeforeUnload = true,
+    disabled = false,
+    withResolver = false,
+  } = opts
+  const router = injectRouter()
+  const { history } = router
+
+  const resolver = Angular.signal<BlockerResolver>({
+    status: 'idle',
+    current: undefined,
+    next: undefined,
+    action: undefined,
+    proceed: undefined,
+    reset: undefined,
+  })
+
+  Angular.effect((onCleanup) => {
+    const blockerFnComposed = async (blockerFnArgs: BlockerFnArgs) => {
+      function getLocation(
+        location: HistoryLocation,
+      ): AnyShouldBlockFnLocation {
+        const parsedLocation = router.parseLocation(location)
+        const matchedRoutes = router.getMatchedRoutes(parsedLocation.pathname)
+        if (matchedRoutes.foundRoute === undefined) {
+          return {
+            routeId: '__notFound__',
+            fullPath: parsedLocation.pathname,
+            pathname: parsedLocation.pathname,
+            params: matchedRoutes.routeParams,
+            search: parsedLocation.search,
+          }
+        }
+        return {
+          routeId: matchedRoutes.foundRoute.id,
+          fullPath: matchedRoutes.foundRoute.fullPath,
+          pathname: parsedLocation.pathname,
+          params: matchedRoutes.routeParams,
+          search: parsedLocation.search,
+        }
+      }
+
+      const current = getLocation(blockerFnArgs.currentLocation)
+      const next = getLocation(blockerFnArgs.nextLocation)
+
+      if (
+        current.routeId === '__notFound__' &&
+        next.routeId !== '__notFound__'
+      ) {
+        return false
+      }
+
+      const shouldBlock = await shouldBlockFn({
+        action: blockerFnArgs.action,
+        current: current as MakeShouldBlockFnLocationUnion<TRouter>,
+        next: next as MakeShouldBlockFnLocationUnion<TRouter>,
+      })
+      if (!withResolver) {
+        return shouldBlock
+      }
+
+      if (!shouldBlock) {
+        return false
+      }
+
+      const promise = new Promise<boolean>((resolve) => {
+        resolver.set({
+          status: 'blocked',
+          current: current as MakeShouldBlockFnLocationUnion<TRouter>,
+          next: next as MakeShouldBlockFnLocationUnion<TRouter>,
+          action: blockerFnArgs.action,
+          proceed: () => resolve(false),
+          reset: () => resolve(true),
+        })
+      })
+
+      const canNavigateAsync = await promise
+      resolver.set({
+        status: 'idle',
+        current: undefined,
+        next: undefined,
+        action: undefined,
+        proceed: undefined,
+        reset: undefined,
+      })
+
+      return canNavigateAsync
+    }
+    const isDisabled = typeof disabled === 'function' ? disabled() : disabled
+    const disposeBlock = isDisabled
+      ? undefined
+      : history.block({ blockerFn: blockerFnComposed, enableBeforeUnload })
+
+    onCleanup(() => disposeBlock?.())
+  })
+
+  return resolver.asReadonly() as any
+}

package/src/injectCanGoBack.ts

@@ -0,0 +1,11 @@
+import { injectRouter } from './injectRouter'
+import { injectStore } from './injectStore'
+
+export function injectCanGoBack() {
+  const router = injectRouter()
+
+  return injectStore(
+    router.stores.location,
+    (location) => location.state.__TSR_index !== 0,
+  )
+}

package/src/injectErrorState.ts

@@ -0,0 +1,21 @@
+import * as Angular from '@angular/core'
+
+export const ERROR_STATE_INJECTOR_TOKEN = new Angular.InjectionToken<{
+  error: Error
+  reset: () => void
+  info: { componentStack: string }
+}>('ERROR_STATE_INJECTOR_TOKEN')
+
+/**
+ * Injects the error state to the error componenet.
+ */
+
+export function injectErrorState() {
+  const errorState = Angular.inject(ERROR_STATE_INJECTOR_TOKEN, {
+    optional: true,
+  })
+  if (!errorState) {
+    throw new Error('injectErrorState was called outside of an error component')
+  }
+  return errorState
+}

package/src/injectIntersectionObserver.ts

@@ -0,0 +1,28 @@
+import * as Angular from '@angular/core'
+
+export function injectIntersectionObserver(
+  callback: (entry: IntersectionObserverEntry | undefined) => void,
+  intersectionObserverOptions: IntersectionObserverInit,
+  disabled: () => boolean,
+) {
+  const elementRef = Angular.inject(Angular.ElementRef)
+
+  Angular.afterRenderEffect((onCleanup) => {
+    const isIntersectionObserverAvailable =
+      typeof IntersectionObserver === 'function'
+
+    const element = elementRef.nativeElement as HTMLElement | null
+    if (!element || !isIntersectionObserverAvailable || disabled()) return
+
+    const observer = new IntersectionObserver(
+      ([entry]) => callback(entry),
+      intersectionObserverOptions,
+    )
+
+    observer.observe(element)
+
+    onCleanup(() => {
+      observer.disconnect()
+    })
+  })
+}

package/src/injectLoaderData.ts

@@ -0,0 +1,49 @@
+import { injectMatch } from './injectMatch'
+import type * as Angular from '@angular/core'
+import type {
+  AnyRouter,
+  RegisteredRouter,
+  ResolveUseLoaderData,
+  StrictOrFrom,
+  UseLoaderDataResult,
+} from '@benjavicente/router-core'
+
+export interface InjectLoaderDataBaseOptions<
+  TRouter extends AnyRouter,
+  TFrom,
+  TStrict extends boolean,
+  TSelected,
+> {
+  select?: (match: ResolveUseLoaderData<TRouter, TFrom, TStrict>) => TSelected
+}
+
+export type InjectLoaderDataOptions<
+  TRouter extends AnyRouter,
+  TFrom extends string | undefined,
+  TStrict extends boolean,
+  TSelected,
+> = StrictOrFrom<TRouter, TFrom, TStrict> &
+  InjectLoaderDataBaseOptions<TRouter, TFrom, TStrict, TSelected>
+
+export type InjectLoaderDataRoute<out TFrom> = <
+  TRouter extends AnyRouter = RegisteredRouter,
+  TSelected = unknown,
+>(
+  opts?: InjectLoaderDataBaseOptions<TRouter, TFrom, true, TSelected>,
+) => Angular.Signal<UseLoaderDataResult<TRouter, TFrom, true, TSelected>>
+
+export function injectLoaderData<
+  TRouter extends AnyRouter = RegisteredRouter,
+  const TFrom extends string | undefined = undefined,
+  TStrict extends boolean = true,
+  TSelected = unknown,
+>(
+  opts: InjectLoaderDataOptions<TRouter, TFrom, TStrict, TSelected>,
+): Angular.Signal<UseLoaderDataResult<TRouter, TFrom, TStrict, TSelected>> {
+  return injectMatch({
+    from: opts.from!,
+    strict: opts.strict as true | undefined,
+    select: (s: any) =>
+      opts.select ? opts.select(s.loaderData) : s.loaderData,
+  } as any) as any
+}