added generic types for StrategySetupService and extending default st…

…rategy names with custom ones

libs/template/src/lib/render-strategies/interfaces/add-strategy-request.interface.ts

@@ -1,8 +1,9 @@
-import { StrategyConstructorType } from './strategy-constructor.type';
+import { StrategyConstructor } from './strategy-constructor.type';
+import { DefaultStrategyName } from './default-strategy-name.type';
 
-export interface AddStrategyRequest {
-  name: string;
-  constructor: StrategyConstructorType;
+export interface AddStrategyRequest<S extends string = DefaultStrategyName> {
+  name: S;
+  constructor: StrategyConstructor;
   options?: {
     setAsDefault: boolean;
     setAsOutOfViewPortDefault: boolean;

libs/template/src/lib/render-strategies/interfaces/default-strategies.interface.ts

@@ -0,0 +1,10 @@
+import { NoopStrategyConstructor } from './noop-strategy-constructor.type';
+import { StrategyConstructor } from './strategy-constructor.type';
+
+export interface DefaultStrategies {
+  global: StrategyConstructor;
+  native: StrategyConstructor;
+  local: StrategyConstructor;
+  detach: StrategyConstructor;
+  noop: NoopStrategyConstructor;
+}

libs/template/src/lib/render-strategies/interfaces/default-strategy-name.type.ts

@@ -0,0 +1,3 @@
+import { DefaultStrategies } from './default-strategies.interface';
+
+export type DefaultStrategyName = keyof DefaultStrategies;

libs/template/src/lib/render-strategies/interfaces/extended-strategy.d.ts

@@ -0,0 +1,9 @@
+import { NoopStrategyConstructor } from './noop-strategy-constructor.type';
+import { StrategyConstructor } from './strategy-constructor.type';
+import { DefaultStrategyName } from './default-strategy-name.type';
+
+export type ExtendedStrategies<S extends string = DefaultStrategyName> = {
+  [key in S | DefaultStrategyName]:
+    | StrategyConstructor
+    | NoopStrategyConstructor;
+};

libs/template/src/lib/render-strategies/interfaces/noop-strategy-constructor.type.ts

@@ -1,3 +1,8 @@
-import { RenderStrategy } from '../../core/render-aware';
+import {
+  RenderStrategy,
+  RenderStrategyFactoryConfig
+} from '../../core/render-aware';
 
-export type NoopStrategyConstructorType = () => RenderStrategy;
+export type NoopStrategyConstructor = (
+  config?: RenderStrategyFactoryConfig
+) => RenderStrategy;

libs/template/src/lib/render-strategies/interfaces/strategy-constructor.type.ts

@@ -3,6 +3,6 @@ import {
   RenderStrategyFactoryConfig
 } from '../../core/render-aware';
 
-export type StrategyConstructorType = <T>(
+export type StrategyConstructor = (
   config: RenderStrategyFactoryConfig
 ) => RenderStrategy;

libs/template/src/lib/render-strategies/interfaces/strategy-setup-state.interface.ts

@@ -1,8 +1,8 @@
-import { AvailableStrategies } from './available-strategies.interface';
-import { StrategyNameType } from './strategy-name.type';
+import { ExtendedStrategies } from './extended-strategy';
+import { DefaultStrategyName } from './default-strategy-name.type';
 
-export interface StrategySetupState {
-  strategies: AvailableStrategies;
-  currentStrategy: StrategyNameType;
-  currentOutOfViewportStrategy: StrategyNameType;
+export interface StrategySetupState<S extends string = DefaultStrategyName> {
+  strategies: ExtendedStrategies<S>;
+  currentStrategy: keyof ExtendedStrategies<S>;
+  currentOutOfViewportStrategy: keyof ExtendedStrategies<S>;
 }

libs/template/src/lib/render-strategies/strategy-setup.service.ts

@@ -1,33 +1,37 @@
 import { Injectable } from '@angular/core';
 import { patch, RxState } from '@rx-angular/state';
-import { StrategyNameType } from './interfaces/strategy-name.type';
-import { availableStrategies } from './constants/default-strategies.constant';
 import { Subject } from 'rxjs';
-import { StrategySetupState } from './interfaces/strategy-setup-state.interface';
+import { availableStrategies } from './constants/default-strategies.constant';
 import { AddStrategyRequest } from './interfaces/add-strategy-request.interface';
-import { AvailableStrategies } from './interfaces/available-strategies.interface';
+import { ExtendedStrategies } from './interfaces/extended-strategy';
+import { DefaultStrategyName } from './interfaces/default-strategy-name.type';
+import { StrategySetupState } from './interfaces/strategy-setup-state.interface';
 
 @Injectable({ providedIn: 'root' })
-export class StrategySetupService extends RxState<StrategySetupState> {
-  private strategyChange$ = new Subject<StrategyNameType>();
-  private outOfViewportStrategyChange$ = new Subject<StrategyNameType>();
-  private newStrategyRegistration$ = new Subject<AddStrategyRequest>();
+export class StrategySetupService<
+  S extends string = DefaultStrategyName
+> extends RxState<StrategySetupState<keyof ExtendedStrategies<S>>> {
+  private strategyChange$ = new Subject<keyof ExtendedStrategies<S>>();
+  private outOfViewportStrategyChange$ = new Subject<
+    keyof ExtendedStrategies<S>
+  >();
+  private newStrategyRegistration$ = new Subject<AddStrategyRequest<S>>();
 
   strategy$ = this.select('currentStrategy');
   outOfViewportStrategy$ = this.select('currentOutOfViewportStrategy');
 
-  get strategy(): StrategyNameType {
+  get strategy(): keyof ExtendedStrategies<S> {
     return this.get().currentStrategy;
   }
 
-  get outOfViewportStrategy(): StrategyNameType {
+  get outOfViewportStrategy(): keyof ExtendedStrategies<S> {
     return this.get().currentOutOfViewportStrategy;
   }
 
   constructor() {
     super();
     this.set({
-      strategies: availableStrategies,
+      strategies: availableStrategies as ExtendedStrategies<S>,
       currentStrategy: 'local',
       currentOutOfViewportStrategy: 'noop'
     });
@@ -50,7 +54,7 @@ export class StrategySetupService extends RxState<StrategySetupState> {
     this.connect(this.newStrategyRegistration$, (state, strategy) => ({
       strategies: patch(state.strategies, {
         [strategy.name]: strategy.constructor
-      }),
+      } as Partial<ExtendedStrategies<S>>),
       currentStrategy: strategy.options?.setAsDefault
         ? strategy.name
         : state.currentStrategy,
@@ -60,28 +64,28 @@ export class StrategySetupService extends RxState<StrategySetupState> {
     }));
   }
 
-  changeStrategy(strategy: StrategyNameType) {
+  changeStrategy(strategy: keyof ExtendedStrategies<S>) {
     this.strategyChange$.next(strategy);
   }
 
-  changeOutOfViewportStrategy(strategy: StrategyNameType) {
+  changeOutOfViewportStrategy(strategy: keyof ExtendedStrategies<S>) {
     this.outOfViewportStrategyChange$.next(strategy);
   }
 
-  addNewStrategy(request: AddStrategyRequest) {
+  addNewStrategy(request: AddStrategyRequest<S>) {
     this.newStrategyRegistration$.next(request);
   }
 
   private strategyExists(
-    strategies: AvailableStrategies,
-    strategy: StrategyNameType
+    strategies: ExtendedStrategies<S>,
+    strategy: keyof ExtendedStrategies<S>
   ): boolean {
     const isExisting = strategies[strategy];
 
     if (!isExisting) {
       console.warn(`Strategy ${strategy} not found`);
     }
 
-    return isExisting;
+    return !!isExisting;
   }
 }

libs/template/src/lib/render-strategies/tokens/available-strategies.token.ts

@@ -1,8 +1,8 @@
 import { InjectionToken } from '@angular/core';
-import { AvailableStrategies } from '../interfaces/available-strategies.interface';
+import { DefaultStrategies } from '../interfaces/default-strategies.interface';
 import { availableStrategies } from '../constants/default-strategies.constant';
 
-export const RX_AVAILABLE_STRATEGIES = new InjectionToken<AvailableStrategies>(
+export const RX_AVAILABLE_STRATEGIES = new InjectionToken<DefaultStrategies>(
   'Available strategies',
   {
     providedIn: 'root',

libs/template/src/lib/render-strategies/tokens/default-out-of-viewport-strategy.token.ts

@@ -1,8 +1,8 @@
 import { InjectionToken } from '@angular/core';
-import { StrategyNameType } from '../interfaces/strategy-name.type';
+import { DefaultStrategyName } from '../interfaces/default-strategy-name.type';
 
 export const RX_ANGULAR_DEFAULT_OUT_OF_VIEWPORT_STRATEGY = new InjectionToken<
-  StrategyNameType
+  DefaultStrategyName
 >('Default out of viewport strategy', {
   providedIn: 'root',
   factory: () => 'noop'

libs/template/src/lib/render-strategies/tokens/default-strategy.token.ts

@@ -1,10 +1,9 @@
 import { InjectionToken } from '@angular/core';
-import { StrategyNameType } from '../interfaces/strategy-name.type';
+import { DefaultStrategyName } from '../interfaces/default-strategy-name.type';
 
-export const RX_ANGULAR_DEFAULT_STRATEGY = new InjectionToken<StrategyNameType>(
-  'Default strategy',
-  {
-    providedIn: 'root',
-    factory: () => 'local'
-  }
-);
+export const RX_ANGULAR_DEFAULT_STRATEGY = new InjectionToken<
+  DefaultStrategyName
+>('Default strategy', {
+  providedIn: 'root',
+  factory: () => 'local'
+});