How to use the change-emitter.createChangeEmitter function in change-emitter

function usage() {
    // https://github.com/acdlite/change-emitter#usage

    const emitter = createChangeEmitter()

    // Called `listen` instead of `subscribe` to avoid confusion with observable spec
    const unlisten = emitter.listen((...args) => {
        console.log(args)
    })

    emitter.emit(1, 2, 3) // logs `[1, 2, 3]`
    unlisten()
    emitter.emit(4, 5, 6) // doesn't log
}

function untypedEmitter() {
    const { emit, listen } = createChangeEmitter();

    const unlisten0 = listen(() => {/* do something */});
    const unlisten1 = listen(value => {/* do something with value */});
    const unlisten2 = listen((value1, value2) => {/* do something with values */});
    const unlistenArgs = listen((...args: any[]) => {/* do something with values */});

    emit();
    emit("hello");
    emit("hello", "world");
    emit(1, 2, 3, 4, 5);

    unlisten0();
    unlisten1();
    unlisten2();
    unlistenArgs();
}

function emitterOf0Args() {
    const { emit, listen }: ChangeEmitterOf0 = createChangeEmitter();

    const unlisten = listen(() => { });
    // const unlisten = listen(value => {}); // SYNTAX ERROR

    emit();
    // emit("hello"); // SYNTAX ERROR

    unlisten();
}

constructor() {
      super()
      this.driversSubscription = []
      this.myId = myId
      this.state$ = state$
      this.update = update
      this.updateGlobal = updateGlobal
      this.state = { vdom: null }
      this.eventMap = {}
      this.active = true
      this.curState = {}

      this.propsEmitter = createChangeEmitter()


      this.props$ = Observable.create(observer => {
        this.propsEmitter.listen(props => {
          if (props) {
            observer.next(props)
          } else {
            observer.complete()
          }
        })
      })

      // 没有lens的组件，不与global连接，自己维护状态
      if (type == 'empty-lens') {
        this.myId = uniqueId('dive-isolate')
        this.state$ = new BehaviorSubject(_ => initState).pipe(

var childInstance = renderWithStream(childElement, instance && instance.childInstance, state, stateMap);
      var _dom = childInstance.dom;
      newInstance = { dom: _dom, element: element, childInstance: childInstance, publicInstance: publicInstance };
    }
    return newInstance;
  };
}

function formatProps(k) {
  if (k.startsWith('on')) return k.toLowerCase();
  return k;
}

var stateMapPointer = new Map();

var emitter = createChangeEmitter();
// single UI thread; this is the observable that sticks around and swaps out source
var UIthread = new Observable(function (observer) {
  emitter.listen(function (x) {
    // debugger // success! thread switching!
    observer.next(x);
  });
});
// mount the vdom on to the dom and 
// set up the runtime from sources and
// patch the vdom
// ---
// returns an unsubscribe method you can use to unmount
function mount(rootElement, container) {
  // initial, throwaway-ish frame
  var _renderStream = renderStream(rootElement, {}, undefined, stateMapPointer),
      source = _renderStream.source,

const createStore = (reducer: Function, initialState: any) => {
        let state = initialState
        const emitter = createChangeEmitter()

        function dispatch(action: any) {
            state = reducer(state, action)
            emitter.emit()
            return action
        }

        function getState() {
            return state
        }

        return {
            dispatch,
            getState,
            subscribe: emitter.listen
        }

function emitterOf2Args() {
    const { emit, listen } = createChangeEmitter();

    const unlisten = listen((value, success) => { value.length > 0 === success });

    emit("hello", true);

    unlisten();
}

function emitterOf1Args() {
    const { emit, listen } = createChangeEmitter();

    const unlisten = listen(value => { value.length });

    emit("hello");

    unlisten();
}

export function createHandler(_fn) {
  const emitter = createChangeEmitter()
  let handler = x => {
    emitter.emit(x)
  }
  handler.$ = new Observable(observer => {
    return emitter.listen(value => {
      observer.next(_fn ? _fn(value) : value)
    }
    )
  })
  return handler
}

function ComponentFromStream() {
        var _config$fromESObserva;

        var _temp, _this, _ret;

        classCallCheck(this, ComponentFromStream);

        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return _ret = (_temp = (_this = possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = { vdom: null }, _this.propsEmitter = createChangeEmitter(), _this.props$ = config$$1.fromESObservable((_config$fromESObserva = {
          subscribe: function subscribe(observer) {
            var unsubscribe = _this.propsEmitter.listen(function (props) {
              if (props) {
                observer.next(props);
              } else {
                observer.complete();
              }
            });
            return { unsubscribe: unsubscribe };
          }
        }, _config$fromESObserva[$$observable] = function () {
          return this;
        }, _config$fromESObserva)), _this.vdom$ = config$$1.toESObservable(propsToVdom(_this.props$)), _temp), possibleConstructorReturn(_this, _ret);
      }