How to use the zen-observable function in zen-observable

export default function points() {
    return new Observable(observer => {
        let cancelMouse = listen(document, 'mousemove').subscribe(
            event => observer.next(point(event.pageX, event.pageY, event.target))
        );
        let cancelFinger = listen(document, 'touchmove').subscribe(event => {
            // sum all the vectors and return the angle
            var touch = event.changedTouches[0];
            observer.next(point(touch.pageX, touch.pageY, event.target));
        });
        return () => {
            cancelMouse();
            cancelFinger();
        };
    });
}

export function Interval(tick = 1000, tickData = Symbol('tick')) {
  return new Observable(observer => {
    let timer = () => setTimeout(() => {
      if (typeof tickData === 'function') tickData = tickData()
      observer.next(tickData);
      timer()
      // observer.complete();
    }, tick);
    timer()
  
    // On unsubscription, cancel the timer
    return () => clearTimeout(timer);

  })
}

export function startWith(obs, val) {
  return new Observable(observer => {
    observer.next(val) // immediately output this value
    const handler = obs.subscribe(x => observer.next(x))
    return () => handler()
  })
}

test('isObservable', t => {
	t.false(isObservable(null));
	t.false(isObservable({}));
	t.false(isObservable(new Listr([])));
	t.false(isObservable(new Promise(() => {})));
	t.true(isObservable(new RxObservable(() => {})));
	t.true(isObservable(new ZenObservable(() => {})));
});

function Test ({props}) {
      return new Observable((observer) => {
        observer.next(props.input)
      })
    }

function Test () {
        return new Observable((observer) => {
          fetchSpy()
          observer.next(3)
        })
      }

function buildResources(resources, target, context) {
  return new Observable(observer => {
    const idPad = padEnd(max(resources.map(r => r.id.length)));

    build(resources, {
      async read(source, _, count) {
        observer.next(
          `${context.verbose ? "Resources: " : ""}${idPad(
            source.id
          )} ${count}/${resources.length}`
        );
        return await source.content;
      },
      async write(source, set) {
        const baseName = path.basename(set.id);
        const dirName = path.dirname(set.id);
        const filePath = path.resolve(
          target,

function buildDemoFiles(datasets, target, context) {
  return new Observable(observer => {
    const { app, rewriter } = context;
    const fileSets = getFileSets(datasets);
    const idPad = padEnd(max(fileSets.map(e => e.id.length)));

    build(fileSets, {
      read(file, files, count) {
        const set = file.pattern;
        observer.next(
          `${context.verbose ? "Demo files: " : ""}${idPad(
            file.id
          )} ${count}/${files.length}`
        );
        return getPatternFile(
          app,
          set.id,
          {

function buildDemos(datasets, target, context) {
  return new Observable(observer => {
    const { app, rewriter } = context;

    const envs = getEnvSets(datasets);
    const idPad = padEnd(max(envs.map(env => env.id.length)));

    build(envs, {
      async read(set, sets, count) {
        observer.next(
          `${context.verbose ? "Demos: " : ""}${idPad(
            set.id
          )} ${count}/${envs.length}`
        );
        return await getPatternDemo(
          app,
          set.id,
          { environments: set.env },

pxtnDecoder.addEventListener("message", function onmessage(e) {
                    const data = e.data;
                    if (sessionId !== data.sessionId) return;

                    const stream = (type === "stream") ? new Observable(observer => {
                        function handler(e) {
                            const data = e.data;
                            if(sessionId !== data.sessionId) return;

                            if(data.done) {
                                observer.complete();
                                pxtnDecoder.removeEventListener("message", handler);
                            }

                            observer.next(data.streamBuffer);
                        }

                        pxtnDecoder.addEventListener("message", handler);

                        return () => {
                            pxtnDecoder.removeEventListener("message", handler);