Component store wrapper

import { Inject, Injectable, InjectionToken, OnDestroy, Optional } from "@angular/core";
import { ComponentStore } from "@ngrx/component-store";
import { Observable, Subscription } from "rxjs";
import { globlaInjector, SYNERGY_CONFIG } from "../../base";
import { SReduxDevtools, SReduxDevtoolsInstance } from "./synergy-redux-devtools";

export const SSTORE_INITIAL_STATE_TOKEN = new InjectionToken ("s-store Initial State");
export const SSTORE_REDUX_DEVTOOL_NAME = new InjectionToken ("s-store State name");

@Injectable ()
export class SStore<S extends object> implements OnDestroy {

  constructor (@Optional () @Inject (SSTORE_INITIAL_STATE_TOKEN) defaultState?: S, @Optional () @Inject (SSTORE_REDUX_DEVTOOL_NAME) private reduxDevtoolsName?: string) {
    if (reduxDevtoolsName) {
      if (!environment.production) {
        const reduxDevtools = globlaInjector.get (SReduxDevtools);
        this.devtoolsInstance = reduxDevtools.connect (reduxDevtoolsName);
      } // if
    } // if

    this.componentStore = new ComponentStore<S> (defaultState);
    if (this.devtoolsInstance) {
      this.devtoolsInstance.init (defaultState);
    }
  } // constructor

  private componentStore: ComponentStore<S>;
  private devtoolsInstance: SReduxDevtoolsInstance;

  setState (state: S): void {
    this.componentStore.setState (state);
    if (this.devtoolsInstance) {
      this.devtoolsInstance.init (state);
    } // TODO_ANALISI
  } // setState;

  getState (): S {
    return this.get ();
  } // getState

  select (): S;
  select<R> (projector: (s: S) => R): R;
  select<R> (projector?: (s: S) => R): R | S {
    return this.get (projector);
  } // select

  get (): S;
  get<R> (projector: (s: S) => R): R;
  get<R> (projector?: (s: S) => R): R | S {
    return (this.componentStore as any).get (projector);
  } // get

  select$ (): Observable<S>;
  select$<R> (projector: (s: S) => R): Observable<R>;
  select$<R, S1> (s1: Observable<S1>, projector: (s1: S1) => R): Observable<R>;
  select$<R, S1, S2> (s1: Observable<S1>, s2: Observable<S2>, projector: (s1: S1, s2: S2) => R): Observable<R>;
  select$<R, S1, S2, S3> (s1: Observable<S1>, s2: Observable<S2>, s3: Observable<S3>, projector: (s1: S1, s2: S2, s3: S3) => R): Observable<R>;
  select$<R, S1, S2, S3, S4> (s1: Observable<S1>, s2: Observable<S2>, s3: Observable<S3>, s4: Observable<S4>, projector: (s1: S1, s2: S2, s3: S3, s4: S4) => R): Observable<R>;
  select$<O extends Array<Observable<unknown> | ProjectorFn>, R, ProjectorFn = (...a: unknown[]) => R> (...args: O): Observable<R> | Observable<S> {
    if (args && args.length) {
      return (this.componentStore as any).select (...args);
    } else {
      return this.componentStore.state$;
    } // if - else
  } // select$

  selectAsync$<R> (projector: (s: S) => R): Observable<R>;
  selectAsync$<O extends Array<Observable<unknown> | ProjectorFn>,
    R,
    ProjectorFn = (...a: unknown[]) => R> (...args: O): Observable<R> {
    (args as any).push ({ debounce: true });
    return (this.componentStore as any).select (...args);
  } // selectSync$

  updater<V> (updaterFn: (state: S, value: V) => S, actionName?: string): unknown extends V ? () => void : (t: V | Observable<V>) => Subscription {
    const wrapUpdaterFn = (state: S, value: V) => {
      const newState = updaterFn (state, value);
      if (this.devtoolsInstance) {
        this.devtoolsInstance.send (actionName || this.reduxDevtoolsName, newState);
      } // if
      return newState;
    };
    return this.componentStore.updater (wrapUpdaterFn);
  } // updater

  update (updaterFnOrPatch: ((state: S) => S) | Partial<S>, actionName?: string): void {
    let updaterFn: (state: S) => S;
    if (typeof updaterFnOrPatch === "function") {
      updaterFn = updaterFnOrPatch;
    } else {
      updaterFn = (s: S) => ({ ...s, ...updaterFnOrPatch });
    } // if - else
    this.updater (updaterFn, actionName) ();
  } // update

  effect<ProvidedType = void,
    OriginType extends Observable<ProvidedType> | unknown = Observable<ProvidedType>,
    ObservableType = OriginType extends Observable<infer A> ? A : never,
    ReturnType = ProvidedType | ObservableType extends void
                 ? () => void
                 : (observableOrValue: ObservableType | Observable<ObservableType>) => Subscription> (generator: (origin$: OriginType) => Observable<unknown>): ReturnType {
    return this.componentStore.effect (generator);
  } // effect

  ngOnDestroy (): void {
    this.destroy ();
  } // ngOnDestroy

  destroy (): void {
    this.componentStore.ngOnDestroy ();
  } // destroy

} // SStore

export interface SReduxDevtoolsInstance {
  init (initialState: unknown): void;
  send (actionName: string, state: unknown): void;
} // SReduxDevtoolsInstance

@Injectable ({
  providedIn: "root"
})
export class SReduxDevtools {

  constructor (
  ) {
    this.reduxDevtoolsExtension = window ? (window as any).__REDUX_DEVTOOLS_EXTENSION__ : null;
  } // constructor

  private reduxDevtoolsExtension: { connect: (config: { name: string }) => SReduxDevtoolsInstance };

  connect (name: string): SReduxDevtoolsInstance {
    if (this.reduxDevtoolsExtension) {
      return this.reduxDevtoolsExtension.connect ({ name: name });
    } else {
      return null;
    } // if - else
  } // connect

} // SReduxDevtools