constructor(private _streamAdapter: StreamAdapter,
             private _mockConfig: MockConfig) {
   if (_mockConfig.elements) {
     this._elements = _mockConfig.elements;
   } else {
     this._elements = _streamAdapter.adapt(xs.empty(), xsSA.streamSubscribe);
   }
 }

export function convertStream (stream: any, sourceSA: StreamAdapter, targetSA: StreamAdapter) {
  return targetSA.isValidStream(stream)
    ? stream
    : targetSA.adapt(stream, sourceSA.streamSubscribe)
}

 constructor(html$: Stream<string>,
             private runSA: StreamAdapter) {
   this._html$ = html$;
   this._empty$ = runSA.adapt(xs.empty(), xsSA.streamSubscribe);
 }

 proxyStream.proxy = (target: Stream) => {
   if (!target || !adapter.isValidStream(target)){
     throw new Error('You should provide a valid target stream to proxy')
   }
   if (targetStream){
     throw new Error('You may provide only one target stream to proxy')
   }
   targetStream = composeFn(target)
   proxyStream.__proxyRefs = 0      
   return adapter.adapt({}, (_: any, observer: Observer<any>) => {        
     let dispose = adapter.streamSubscribe(target, observer)        
     if (proxyStream.__proxyRefs++ === 0) {          
       proxyDispose = adapter.streamSubscribe(
         targetStream, proxyObserver
       )          
     }
     return () => {
       dispose()
       if (--proxyStream.__proxyRefs === 0) {
         proxyDispose()
         proxyObserver.complete()
         if (proxyStream.__onProxyDispose) {
           proxyStream.__onProxyDispose()
         }
       }
     }
   })
 }

    return function (sources: any, ...rest: any[]) {
      let circular$ = sources[circularName] = proxy()
      let sinks = dataflow(sources, ...rest) as any

      const proxyStreams: any = {}
      const proxiedSinks: any = {}

      const disposeCircular = adapter.streamSubscribe(
        circular$.proxy(sinks[circularName]), {
          next: () => { }, error: () => { }, complete: () => { }
        }
      )

      const checkAllDisposed = () => {
        let disposed = true
        for (const key in proxyStreams) {
          if (proxyStreams[key].__proxyRefs) {
            disposed = false
          }
        }
        if (disposed) {
          disposeCircular()
        }
      }

      for (const key in sinks) {
        // TODO: decide if we we need 
        // to remove circular$ stream from sinks 
        //if (key === circularName) return
        const sink = sinks[key]
        if (sink && adapter.isValidStream(sink)) {
          proxyStreams[key] = proxy()
          proxiedSinks[key] = proxyStreams[key].proxy(sink)
          proxyStreams[key].__onProxyDispose = checkAllDisposed
          // TODO: probably can use proxy completition
          // if proxy can be subscribed once?
          // adapter.streamSubscribe(proxyStreams[key], {
          //   next: () => { },
          //   error: () => { },
          //   complete: () => { console.log(key + 'completed') }
          // })
        } else {
          proxiedSinks[key] = sink
        }
      }
      return proxiedSinks
    }

  path(pathname: Pathname): RouterSource {
    const scopedNamespace = this._namespace.concat(util.splitPath(pathname));
    const scopedHistory$ = this._runSA.remember(this._history$
      .filter(({pathname: _path}: Location) => isStrictlyInScope(scopedNamespace, _path)));

    const createHref = this._createHref;
    return new RouterSource(scopedHistory$, scopedNamespace, createHref, this._runSA);
  }

 return adapter.adapt({}, (_: any, observer: Observer<any>) => {        
   let dispose = adapter.streamSubscribe(target, observer)        
   if (proxyStream.__proxyRefs++ === 0) {          
     proxyDispose = adapter.streamSubscribe(
       targetStream, proxyObserver
     )          
   }
   return () => {
     dispose()
     if (--proxyStream.__proxyRefs === 0) {
       proxyDispose()
       proxyObserver.complete()
       if (proxyStream.__onProxyDispose) {
         proxyStream.__onProxyDispose()
       }
     }
   }
 })

 public events(eventType: string, options: EventsFnOptions): any {
   const mockConfig = this._mockConfig;
   const keys = Object.keys(mockConfig);
   const keysLen = keys.length;
   for (let i = 0; i < keysLen; i++) {
     const key = keys[i];
     if (key === eventType) {
       return mockConfig[key];
     }
   }
   return this._streamAdapter.adapt(xs.empty(), xsSA.streamSubscribe);
 }

  define(routes: RouteDefinitions): any {
    const namespace = this._namespace;
    const _createHref = this._createHref;
    const createHref = util.makeCreateHref(namespace, _createHref);

    let match$ = this._runSA.remember(this._history$
      .map((location: Location) => {
        const filteredPath = getFilteredPath(namespace, location.pathname);
        const {path, value} = switchPath(filteredPath, routes);
        return {path, value, location, createHref};
      }));

    match$.createHref = createHref;
    return match$;
  }