title: Why the change in state of store is not broadcasted to my component
body: <p>When onMetaSignalChanged() is called in the component, it causes an effect which in turn calls the reducer case rangeSchemasLoadCompletedSuccess. I have debugged the App and its working fine till that point. 
  As you can see rangeSchemasLoadCompletedSuccess updating the rangeSchemas of store state, so I think my rangeSchemas$ observable should get the updated value after that? But its not being updated, Am I missing something?</p>
  
  <p>Model Class:</p>
  
  <pre><code>export interface RangeSchemaViewModel {
   id: number;
   rangeSchemaName: string;
  }
  </code></pre>
  
  <p>In my component I'm selecting the store state as: </p>
  
  <pre><code>export class MyComponent implements OnInit, OnDestroy {
    rangeSchemas$: Observable&lt;RangeSchemaViewModel[]&gt;;
  
    ngOnInit() {
      this.rangeSchemas$ = this.store.pipe(
        select(RawSignalsStoreSelectors.selectRangeSchemasViewModel)
      );
    }
  
     onMetaSignalChanged(event: any) {
       this.store.dispatch(
         RawSignalsStoreActions.changeMetaSignal({ id: event.meta_Signal_Id })
       );
     }
  
    //onmetaSignalChanged, Action is called which is updating the state of rangeSchemas$
  }
  </code></pre>
  
  <p>Here is my selector code:</p>
  
  <pre><code>const getRangeSchemas = (state: State): RangeSchema[] =&gt; state.rangeSchemas;
  
  export const selectRangeSchemasState: MemoizedSelector&lt;
    object,
    State
  &gt; = createFeatureSelector&lt;State&gt;('raw-signals');
  
  export const selectRangeSchemasViewModel: MemoizedSelector&lt; 
    object,
    RangeSchemaViewModel[]
  &gt; = createSelector(
      selectRangeSchemasState,
      getRangeSchemas,
      (state, rangeSchemas) =&gt; {
          return rangeSchemas.map((item) =&gt;{
              let rangeSchemaViewModel: RangeSchemaViewModel;
              rangeSchemaViewModel.id= item.mapping.id;
              rangeSchemaViewModel.rangeSchemaName= item.mapping.rangeSchemaName;
              return rangeSchemaViewModel;
          })
      });
  </code></pre>
  
  <p>Reducer Code:</p>
  
  <pre><code>on(rawSignalsActions.changeMetaSignal, (state, { id }) =&gt; ({
  ...state,
  linkedMetaSignal: state.metaSignals.filter(item =&gt; item.id === id)[0]
   })),
  on(rawSignalsActions.rangeSchemasLoadCompletedError, state =&gt; ({
      ...state,
      loading: { ...state.loading, rangeSchemas: false }
   })),
  on(rawSignalsActions.rangeSchemasLoadCompletedSuccess,
      // tslint:disable-next-line: no-shadowed-variable
      (state, { rangeSchemas }) =&gt; ({
        ...state,
        rangeSchemas,
        loading: { ...state.loading, rangeSchemas: false }
      })
    )
  </code></pre>
  
  <p>Effects Code: </p>
  
  <pre><code>  getRangeSchemas$ = createEffect(() =&gt;
    this.actions$.pipe(
        ofType(RawSignalsActions.changeMetaSignal),
        concatMap(action =&gt; this.rawSignalsDataService.getRangeSchemas(action.id).pipe(
          map(rs1 =&gt; this.constructSignalCounts(rs1)),
          map(rs2 =&gt; RawSignalsActions.rangeSchemasLoadCompletedSuccess( { rangeSchemas: rs2 })),
            catchError(err =&gt; of(RawSignalsActions.rangeSchemasLoadCompletedError({ error: err })))
        )),
    ));
  
    constructSignalCounts = ( rangeSchemas: RangeSchema[]) =&gt; {
      for (var rangeSchema of rangeSchemas){
          let signalCounts: SignalCount[] = [];
          for (var abstractSignal of rangeSchema.abstractSignals) {
              let signalCount: SignalCount = { range: "0", populationSize: 0, populationPerc: 0, lowRange: 0, highRange:0 };
              signalCount.range = abstractSignal.abstractSignal.name;
              signalCount.populationSize = 20;
              signalCount.populationPerc = 40;
              if (rangeSchema.mapping.type == 2) {    // 2 -&gt; numeric, 3 -&gt; Text
                // actually type will come from Signal Range Schema
                signalCount.lowRange = abstractSignal.numericMappings[0].minValue;
                signalCount.highRange = abstractSignal.numericMappings[0].maxValue;
              }
              signalCounts.push(signalCount);
            }
            rangeSchema.signalCounts = signalCounts;
  
      }
      return rangeSchemas;
    };
  </code></pre>