@benjavicente/angular-router-experimental 1.142.11

package/src/injectStore.ts

@@ -0,0 +1,87 @@
+import {
+  assertInInjectionContext,
+  effect,
+  linkedSignal,
+} from '@angular/core'
+import type { CreateSignalOptions, Signal } from '@angular/core'
+
+type ReadableStore<TState> = {
+  state: TState
+}
+
+export function injectStore<TState, TSelected = NoInfer<TState>>(
+  storeOrStoreSignal:
+    | ReadableStore<TState>
+    | (() => ReadableStore<TState>),
+  selector: (state: NoInfer<TState>) => TSelected = (d) =>
+    d as unknown as TSelected,
+  options: CreateSignalOptions<TSelected> = {
+    equal: shallow,
+  },
+): Signal<TSelected> {
+  assertInInjectionContext(injectStore)
+
+  const storeSignal =
+    typeof storeOrStoreSignal === 'function'
+      ? storeOrStoreSignal
+      : () => storeOrStoreSignal
+
+  const slice = linkedSignal(() => selector(storeSignal().state), options)
+
+  effect(() => {
+    slice()
+  })
+
+  return slice.asReadonly()
+}
+
+function shallow<T>(objA: T, objB: T) {
+  if (Object.is(objA, objB)) {
+    return true
+  }
+
+  if (
+    typeof objA !== 'object' ||
+    objA === null ||
+    typeof objB !== 'object' ||
+    objB === null
+  ) {
+    return false
+  }
+
+  if (objA instanceof Map && objB instanceof Map) {
+    if (objA.size !== objB.size) return false
+    for (const [k, v] of objA) {
+      if (!objB.has(k) || !Object.is(v, objB.get(k))) return false
+    }
+    return true
+  }
+
+  if (objA instanceof Set && objB instanceof Set) {
+    if (objA.size !== objB.size) return false
+    for (const v of objA) {
+      if (!objB.has(v)) return false
+    }
+    return true
+  }
+
+  if (objA instanceof Date && objB instanceof Date) {
+    return objA.getTime() === objB.getTime()
+  }
+
+  const keysA = Object.keys(objA)
+  if (keysA.length !== Object.keys(objB).length) {
+    return false
+  }
+
+  for (const key of keysA) {
+    if (
+      !Object.prototype.hasOwnProperty.call(objB, key) ||
+      !Object.is(objA[key as keyof T], objB[key as keyof T])
+    ) {
+      return false
+    }
+  }
+
+  return true
+}

package/src/matchInjectorToken.ts

@@ -0,0 +1,23 @@
+import * as Angular from '@angular/core'
+import type { AnyRouteMatch } from '@benjavicente/router-core'
+
+export type NearestMatchContextValue = {
+  matchId: () => string | undefined,
+  routeId: () => string | undefined,
+  match: () => AnyRouteMatch | undefined,
+  hasPending: () => boolean,
+}
+
+const defaultNearestMatchContext: NearestMatchContextValue = {
+  matchId: () => undefined,
+  routeId: () => undefined,
+  match: () => undefined,
+  hasPending: () => false,
+}
+
+export const MATCH_CONTEXT_INJECTOR_TOKEN = new Angular.InjectionToken<
+  NearestMatchContextValue
+>('MATCH_CONTEXT_INJECTOR', {
+  providedIn: 'root',
+  factory: () => defaultNearestMatchContext,
+})

package/src/renderer/injectIsCatchingError.ts

@@ -0,0 +1,40 @@
+import * as Angular from '@angular/core'
+import { injectRouter } from '../injectRouter'
+import { injectRouterState } from '../injectRouterState'
+import type { AnyRoute } from '@benjavicente/router-core'
+
+export function injectIsCatchingError({
+  matchId,
+}: {
+  matchId: Angular.Signal<string | undefined>
+}): Angular.Signal<boolean> {
+  const router = injectRouter()
+
+  const matches = injectRouterState({
+    select: (s) => s.matches,
+  })
+
+  const matchIndex = Angular.computed(() => {
+    return matches().findIndex((m) => m.id === matchId())
+  })
+
+  return Angular.computed(() => {
+    // The child route will handle the error with the default error component.
+    if (router.options.defaultErrorComponent != null) return false;
+
+    const startingIndex = matchIndex()
+    if (startingIndex === -1) return false
+    const matchesList = matches()
+
+    for (let i = startingIndex + 1; i < matchesList.length; i++) {
+      const descendant = matchesList[i]
+      const route = router.routesById[descendant?.routeId] as AnyRoute
+      // Is catched by a child route with an error component.
+      if (route.options.errorComponent != null) return false
+
+      // Found error status without error component in between.
+      if (descendant?.status === "error") return true
+    }
+    return false
+  })
+}

package/src/renderer/injectRender.ts

@@ -0,0 +1,69 @@
+import {
+  DestroyRef,
+  Injector,
+  ViewContainerRef,
+  effect,
+  inject,
+  inputBinding,
+} from '@angular/core'
+import type { Provider, Type } from '@angular/core'
+
+export type RenderValue =
+  | {
+      key?: string
+      component: Type<any> | null | undefined
+      inputs?: Record<string, () => unknown>
+      providers?: Array<Provider>
+    }
+  | null
+  | undefined
+
+export function injectRender(renderValueFn: () => RenderValue): void {
+  const vcr = inject(ViewContainerRef)
+  const parent = inject(Injector)
+
+  let lastKey: Array<any> = []
+
+  effect(() => {
+    const renderValue = renderValueFn()
+
+    const newKey = resolvedKey(renderValue)
+    if (keysAreEqual(lastKey, newKey)) return
+
+    if (lastKey.length > 0) vcr.clear()
+
+    lastKey = newKey
+
+    const component = renderValue?.component
+    if (!component) return
+
+    const providers = renderValue.providers ?? []
+    const childInjector = Injector.create({ providers, parent })
+    const bindings = Object.entries(renderValue.inputs ?? {}).map(
+      ([name, value]) => inputBinding(name, value),
+    )
+    const cmpRef = vcr.createComponent(component, {
+      injector: childInjector,
+      bindings,
+    })
+    cmpRef.changeDetectorRef.markForCheck()
+  })
+
+  inject(DestroyRef).onDestroy(() => {
+    vcr.clear()
+  })
+}
+
+function resolvedKey(value: RenderValue) {
+  const component = value?.component
+  if (!value || !component) return []
+  return [component, value.key]
+}
+
+function keysAreEqual(a: Array<any>, b: Array<any>) {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}