Merge pull request #27 from dottostack/feat/atomic

feat: deep computed operator

Author: eddort

packages/dotto.x/computed/constants.js

@@ -0,0 +1 @@
+export const DEEP_HANDLER = Symbol.for('deep')

packages/dotto.x/computed/container.js

@@ -3,22 +3,30 @@ import { onOff } from '../lifecycle'
 import { context } from './context'
 import { decorate } from '../utils/decorate'
 import { get_or_create } from '../utils/get_or_create'
+import { DEEP_HANDLER } from './constants'
 
 export const createContainer = (cb, emit, invalidate) => {
   let listeners = new Map()
-  let storeOffHandlers = new Map()
+  let destroys = new Map()
 
   return {
+    listeners,
+    destroys,
+    emit,
+    invalidate,
     unbind() {
-      listeners.forEach(sub => run_all(Object.values(sub)))
+      listeners.forEach(sub => {
+        run_all([...Object.values(sub), sub[DEEP_HANDLER] || (() => {})])
+      })
       listeners.clear()
-      storeOffHandlers.forEach(sub => run_all(Object.values(sub)))
-      storeOffHandlers.clear()
+      destroys.forEach(sub => run_all(Object.values(sub)))
+      destroys.clear()
     },
     add(store, query) {
       let listenerBox = get_or_create(listeners, store, () => ({}))
+      if (listenerBox[DEEP_HANDLER]) return
       // TODO
-      get_or_create(storeOffHandlers, store, () => {
+      get_or_create(destroys, store, () => {
         let unbind = onOff(store, () => {
           listeners.delete(store)
           invalidate(!listeners.size)

packages/dotto.x/computed/deep.d.ts

@@ -0,0 +1,17 @@
+import type { DotXStore } from '../create-store'
+import type { ResolveType } from '../utils/get'
+import type { DotXAtom } from '../create-atom'
+import type { ReadableStore } from './computed'
+
+export function deep<Sub extends ReadableStore>(
+  dep: Sub
+): ReturnType<Sub['get']>
+
+export function deep<Data>(dep: DotXAtom<Data>): Data
+
+export function deep<Data>(dep: DotXStore<Data>): Data
+
+export function deep<Data, Query extends string>(
+  dep: DotXStore<Data>,
+  query: Query
+): ResolveType<Data, Query>

packages/dotto.x/computed/deep.js

@@ -0,0 +1,31 @@
+import { onOff, onChange } from '../lifecycle'
+import { run_all } from '../utils/run_all'
+import { DEEP_HANDLER } from './constants'
+import { target } from './context'
+
+const change = (store, cb) => {
+  let unsubs = [store.listen(() => {}), onChange(store, cb)]
+  return () => run_all(unsubs)
+}
+
+export const deep = (store, query) => {
+  if (store._run) return store.get(true)
+
+  let container = target()
+  if (!container || container.silent) return store.get(query)
+
+  let { listeners, destroys, invalidate, emit } = container
+
+  let listenerBox = listeners.get(store)
+  if (listenerBox && listenerBox[DEEP_HANDLER]) return store.get(query)
+  listeners.set(store, { [DEEP_HANDLER]: change(store, emit) })
+  if (listenerBox) run_all(Object.values(listenerBox))
+  if (!destroys.has(store)) {
+    destroys.set(
+      store,
+      onOff(store, () => invalidate(true))
+    )
+  }
+
+  return store.get(query)
+}