perf: reduce strategy surface and make it a fn

projects/ngx-meta/src/routing/src/current-route-data-metadata-strategy.spec.ts

@@ -1,13 +1,13 @@
-import { MockProvider, MockService } from 'ng-mocks'
+import { MockService } from 'ng-mocks'
 import { ActivatedRouteSnapshot } from '@angular/router'
-import { TestBed } from '@angular/core/testing'
 import {
-  CurrentRouteDataMetadataStrategy,
+  CURRENT_ROUTE_DATA_METADATA_ROUTE_STRATEGY,
   ROUTING_KEY,
 } from './current-route-data-metadata-strategy'
-import { MetadataService } from '../../core'
 
 describe('Current route data metadata strategy', () => {
+  const sut = CURRENT_ROUTE_DATA_METADATA_ROUTE_STRATEGY
+
   describe('resolve', () => {
     it('returns current route snapshot (last child)', () => {
       const dummyRouteMetadata = { title: 'dummy' }
@@ -20,19 +20,7 @@ describe('Current route data metadata strategy', () => {
           },
         },
       } as Partial<ActivatedRouteSnapshot>)
-      const sut = makeSut()
-
-      expect(sut.resolve(rootSnapshot)).toEqual(dummyRouteMetadata)
+      expect(sut(rootSnapshot)).toEqual(dummyRouteMetadata)
     })
   })
 })
-
-function makeSut() {
-  TestBed.configureTestingModule({
-    providers: [
-      CurrentRouteDataMetadataStrategy,
-      MockProvider(MetadataService),
-    ],
-  })
-  return TestBed.inject(CurrentRouteDataMetadataStrategy)
-}

projects/ngx-meta/src/routing/src/current-route-data-metadata-strategy.ts

@@ -1,26 +1,14 @@
 import { ActivatedRouteSnapshot } from '@angular/router'
-import { Injectable } from '@angular/core'
 import { MetadataRouteStrategy } from './metadata-route-strategy'
-import { MetadataService, MetadataValues } from '@davidlj95/ngx-meta/core'
 import { MetadataRouteData } from './metadata-route-data'
 
-@Injectable({ providedIn: 'root' })
-export class CurrentRouteDataMetadataStrategy implements MetadataRouteStrategy {
-  constructor(private readonly metadataService: MetadataService) {}
-
-  resolve<T extends object>(
-    routeSnapshot: ActivatedRouteSnapshot,
-  ): T | undefined {
-    let currentRouteSnapshot: ActivatedRouteSnapshot = routeSnapshot
+export const CURRENT_ROUTE_DATA_METADATA_ROUTE_STRATEGY: MetadataRouteStrategy =
+  (activatedRouteSnapshot) => {
+    let currentRouteSnapshot: ActivatedRouteSnapshot = activatedRouteSnapshot
     while (currentRouteSnapshot.firstChild != null) {
       currentRouteSnapshot = currentRouteSnapshot.firstChild
     }
     return currentRouteSnapshot.data[ROUTING_KEY]
   }
 
-  set(metadata: MetadataValues | undefined): void {
-    this.metadataService.set(metadata)
-  }
-}
-
 export const ROUTING_KEY: keyof MetadataRouteData = 'meta'

projects/ngx-meta/src/routing/src/metadata-route-strategy.ts

@@ -1,12 +1,10 @@
+import { InjectionToken } from '@angular/core'
 import { ActivatedRouteSnapshot } from '@angular/router'
-import { MetadataValues } from '@davidlj95/ngx-meta/core'
 
-export abstract class MetadataRouteStrategy<
-  Metadata extends MetadataValues = MetadataValues,
-> {
-  public abstract resolve(
-    routeSnapshot: ActivatedRouteSnapshot,
-  ): Metadata | undefined
+export type MetadataRouteStrategy = <T>(
+  activatedRouteSnapshot: ActivatedRouteSnapshot,
+) => T | undefined
 
-  public abstract set(metadata: Metadata | undefined): void
-}
+export const METADATA_ROUTE_STRATEGY = new InjectionToken(
+  ngDevMode ? 'NgxMeta Metadata Route Strategy' : 'NgxMetaMRS',
+)

projects/ngx-meta/src/routing/src/provide-routing.ts

@@ -2,15 +2,11 @@ import {
   ENVIRONMENT_INITIALIZER,
   EnvironmentProviders,
   Provider,
+  ValueProvider,
 } from '@angular/core'
-import { CurrentRouteDataMetadataStrategy } from './current-route-data-metadata-strategy'
-import { MetadataRouteStrategy } from './metadata-route-strategy'
 import { RouterListenerService } from './router-listener.service'
-
-export const DEFAULT_METADATA_STRATEGY_PROVIDER: Provider = {
-  provide: MetadataRouteStrategy,
-  useExisting: CurrentRouteDataMetadataStrategy,
-}
+import { CURRENT_ROUTE_DATA_METADATA_ROUTE_STRATEGY } from './current-route-data-metadata-strategy'
+import { METADATA_ROUTE_STRATEGY } from './metadata-route-strategy'
 
 export const ROUTING_INITIALIZER: Provider = {
   provide: ENVIRONMENT_INITIALIZER,
@@ -23,6 +19,15 @@ export const ROUTING_INITIALIZER: Provider = {
   deps: [RouterListenerService],
 }
 
-export function provideRouting(): EnvironmentProviders | Provider[] {
-  return [DEFAULT_METADATA_STRATEGY_PROVIDER, ROUTING_INITIALIZER]
+export const DEFAULT_METADATA_ROUTE_STRATEGY: ValueProvider = {
+  provide: METADATA_ROUTE_STRATEGY,
+  useValue: CURRENT_ROUTE_DATA_METADATA_ROUTE_STRATEGY,
 }
+
+export const ROUTING_PROVIDERS = [
+  DEFAULT_METADATA_ROUTE_STRATEGY,
+  ROUTING_INITIALIZER,
+]
+
+export const provideRouting = (): EnvironmentProviders | Provider[] =>
+  ROUTING_PROVIDERS

projects/ngx-meta/src/routing/src/router-listener.service.spec.ts

@@ -10,9 +10,13 @@ import {
   RouterEvent,
 } from '@angular/router'
 import { EventEmitter, Provider } from '@angular/core'
-import { MetadataRouteStrategy } from './metadata-route-strategy'
+import {
+  METADATA_ROUTE_STRATEGY,
+  MetadataRouteStrategy,
+} from './metadata-route-strategy'
 import { enableAutoSpy } from '@davidlj95/ngx-meta/__tests__/enable-auto-spy'
 import { Subscription } from 'rxjs'
+import { MetadataService } from '../../core'
 
 describe('RouterListenerService', () => {
   enableAutoSpy()
@@ -66,14 +70,17 @@ describe('RouterListenerService', () => {
   describe('when a non-end navigation event is triggered', () => {
     it('should not call any metadata strategy method', () => {
       const events$ = new EventEmitter()
-      const strategy = makeStrategy()
+      const strategy = jasmine.createSpy()
       const sut = makeSut({ events$, strategy })
+      const metadataService = TestBed.inject(
+        MetadataService,
+      ) as unknown as jasmine.SpyObj<MetadataService>
       sut.listen()
 
       events$.emit(makeNavigationEvent(EventType.ActivationEnd))
 
-      expect(strategy.resolve).not.toHaveBeenCalled()
-      expect(strategy.set).not.toHaveBeenCalled()
+      expect(strategy).not.toHaveBeenCalled()
+      expect(metadataService.set).not.toHaveBeenCalled()
     })
   })
 
@@ -95,25 +102,27 @@ describe('RouterListenerService', () => {
     })
 
     describe('when a strategy is provided', () => {
-      it('should call strategy resolve and set', () => {
+      it('should call strategy resolve and set that metadata', () => {
         const metadata = { key: 'value' }
-        const strategy = makeStrategy('single', metadata)
+        const strategy = jasmine.createSpy().and.returnValue(metadata)
         const events$ = new EventEmitter()
         const activatedRoute = MockService(ActivatedRoute)
         const sut = makeSut({
           events$,
           strategy,
           activatedRoute,
         })
+        const metadataService = TestBed.inject(
+          MetadataService,
+        ) as unknown as jasmine.SpyObj<MetadataService>
 
         sut.listen()
 
         events$.emit(makeNavigationEvent(EventType.NavigationEnd))
 
-        expect(strategy.resolve).toHaveBeenCalledOnceWith(
-          activatedRoute.snapshot,
-        )
-        expect(strategy.set).toHaveBeenCalledOnceWith(metadata)
+        expect(strategy).toHaveBeenCalledOnceWith(activatedRoute.snapshot)
+        expect()
+        expect(metadataService.set).toHaveBeenCalledOnceWith(metadata)
       })
     })
   })
@@ -137,11 +146,12 @@ function makeSut(
     RouterListenerService,
     MockProvider(Router, { events: events$ } as Partial<Router>, 'useValue'),
     MockProvider(ActivatedRoute, activatedRoute, 'useValue'),
+    MockProvider(MetadataService),
   ]
 
   if (opts.strategy) {
     providers.push(
-      MockProvider(MetadataRouteStrategy, opts.strategy, 'useValue'),
+      MockProvider(METADATA_ROUTE_STRATEGY, opts.strategy, 'useValue'),
     )
   }
 
@@ -152,16 +162,6 @@ function makeSut(
   return TestBed.inject(RouterListenerService)
 }
 
-function makeStrategy(
-  name: string = 'default',
-  resolvedData: unknown = { dummy: 'metadata' },
-): jasmine.SpyObj<MetadataRouteStrategy> {
-  return MockService(MetadataRouteStrategy, {
-    resolve: jasmine.createSpy(`${name} resolve`).and.returnValue(resolvedData),
-    set: jasmine.createSpy(`${name} set`),
-  }) as jasmine.SpyObj<MetadataRouteStrategy>
-}
-
 function makeNavigationEvent(type: EventType): NavigationEvent {
   return { type } as NavigationEvent
 }

projects/ngx-meta/src/routing/src/router-listener.service.ts

@@ -1,7 +1,11 @@
 import { Inject, Injectable, OnDestroy, Optional } from '@angular/core'
 import { ActivatedRoute, EventType, Router } from '@angular/router'
 import { filter, Subscription } from 'rxjs'
-import { MetadataRouteStrategy } from './metadata-route-strategy'
+import {
+  METADATA_ROUTE_STRATEGY,
+  MetadataRouteStrategy,
+} from './metadata-route-strategy'
+import { MetadataService } from '@davidlj95/ngx-meta/core'
 
 @Injectable({ providedIn: 'root' })
 export class RouterListenerService implements OnDestroy {
@@ -13,8 +17,9 @@ export class RouterListenerService implements OnDestroy {
     private readonly router: Router,
     private readonly activatedRoute: ActivatedRoute,
     @Optional()
-    @Inject(MetadataRouteStrategy)
+    @Inject(METADATA_ROUTE_STRATEGY)
     private readonly strategy: MetadataRouteStrategy | null,
+    private readonly metadataService: MetadataService,
   ) {}
 
   public listen() {
@@ -44,7 +49,7 @@ export class RouterListenerService implements OnDestroy {
             }
             return
           }
-          this.strategy.set(this.strategy.resolve(this.activatedRoute.snapshot))
+          this.metadataService.set(this.strategy(this.activatedRoute.snapshot))
         },
       })
   }

projects/ngx-meta/src/routing/src/routing.module.ts

@@ -1,15 +1,12 @@
 import { ModuleWithProviders, NgModule } from '@angular/core'
-import {
-  DEFAULT_METADATA_STRATEGY_PROVIDER,
-  ROUTING_INITIALIZER,
-} from './provide-routing'
+import { ROUTING_PROVIDERS } from './provide-routing'
 
 @NgModule()
 export class RoutingModule {
   static forRoot(): ModuleWithProviders<RoutingModule> {
     return {
       ngModule: RoutingModule,
-      providers: [DEFAULT_METADATA_STRATEGY_PROVIDER, ROUTING_INITIALIZER],
+      providers: ROUTING_PROVIDERS,
     }
   }
 }