Add ability for computed to handle WritableAtom return values

[haywoood]

I have this use case where i want to return an atom value to computed, and in those cases subscribe/unsubscribe when it's value is updated.

describe('computed', () => {
    it('handles atom return values', () => {
        const $projectId = atom('123')
        const $getProject = memoizeAtom(id => ({ id, name: 'test' }))
        const $computedProject = computed($projectId, $getProject)
        const $project = $getProject('abc')
        expect($computedProject.get()).toEqual({ id: '123', name: 'test' })
        expect($project.get()).toEqual({ id: 'abc', name: 'test' })
    })
})

I have a working copy locally if it helps to see what the changes would be like, not sure how unsavory it might be though lol

let computedStore = (stores, cb, batched) => {
    if (!Array.isArray(stores)) stores = [stores]

    let atomValue
    let previousArgs
    let currentRunId = 0
    let set = () => {
        let args = stores.map($store => $store.get())
        let testArgs = atomValue ? args.concat([atomValue.get()]) : args
        if (
            previousArgs === undefined ||
            testArgs.some((arg, i) => arg !== previousArgs[i])
        ) {
            let runId = ++currentRunId
            previousArgs = testArgs
            let value = cb(...args)
            if (value && value.then && value.t) {
                value.then(asyncValue => {
                    if (runId === currentRunId) {
                        // Prevent a stale set
                        $computed.set(asyncValue)
                    }
                })
            } else if (isReadableAtom(value)) {
                atomValue = value
                return value.subscribe(value => {
                    $computed.set(value)
                })
            } else {
                $computed.set(value)
            }
        }
    }

    let $computed = atom(undefined, Math.max(...stores.map($s => $s.l)) + 1)

    let timer
    let run = batched
        ? () => {
            clearTimeout(timer)
            timer = setTimeout(set)
        }
        : set

    onMount($computed, () => {
        let unbinds = stores.map($store => $store.listen(run, -1 / $computed.l))
        let internalUnbind = set()
        return () => {
            if (isFunction(internalUnbind)) internalUnbind()
            for (let unbind of unbinds) unbind()
        }
    })

    return $computed
}

Any interest in supporting this admittedly edge use-case out of the box?

[ai]

Hm. I think it is not very popular use case.

If you want you create a library for instance.

[haywoood]

Yea that's what I was thinking, but because the diff of supporting it is not too large, didn't know if it might be okay to bake it in :)