observable.ts

interface Observer<T> {
    next(value: T)
    complete()
    error(error: unknown)
}

class Observable<T> {
    constructor(public subscribe: (observer: Observer<T>) => void) {}

    map(mapper: (x: T) => T): Observable<T> {
        return new Observable((observer: Observer<T>) => {
            this.subscribe({
                next: (x: T) => observer.next(mapper(x)),
                complete: observer.complete,
                error: observer.error
            })
        })
    }

    filter(condition: (x: T) => boolean): Observable<T> {
        return new Observable((observer: Observer<T>) => {
            this.subscribe({
                next: (arg: T) => {
                    if (condition(arg)) {
                        observer.next(arg);
                    }
                },
                complete: observer.complete,
                error: observer.error
            })
        })
    }
}

const fromArray = <T>(items: T[]): Observable<T> => {
    return new Observable<T>((observer: Observer<T>) => {
        items.forEach(observer.next);
        observer.complete();
    })
};

const fromInterval = (ms: number): Observable<number> => {
    let i = 0;
    return new Observable<number>((observer: Observer<number>) => {
        const intervalId = setInterval(() => {
            observer.next(i++);
            if (i > 5) {
                clearInterval(intervalId);
            }
        }, ms)
    });
};

fromArray([2, 3, 4, 5, 6])
// fromInterval(500)
    .filter(value => value % 2 === 0)
    .map(value => value * 10)
    .subscribe({
        next: (value) => console.log(value),
        complete: () => console.log('done'),
        error: () => console.log('error!')
    });