simple api, 1st pass

src/index.ts

@@ -23,10 +23,10 @@ export interface Store<State extends object> {
   getState(): Readonly<State>
 }
 
-export class StoreSnapshot<State extends object> implements Store<State> {
+export class LegacyStoreSnapshot<State extends object> implements Store<State> {
   constructor(
     private state: State,
-    private storeDefinition: StoreDefinition<State>
+    private storeDefinition: LegacyStoreDefinition<State>
   ) { }
   get<K extends keyof State>(key: K) {
     return this.state[key]
@@ -45,6 +45,44 @@ export class StoreSnapshot<State extends object> implements Store<State> {
   }
 }
 
+function StoreSnapshot<State extends object>(
+  state: State,
+  storeDefinition: StoreDefinition<State>
+): State {
+  return Object.freeze(Object.preventExtensions(
+    Object.defineProperties({}, mapValues(state, (value, key) => {
+      let d = Object.getOwnPropertyDescriptor(state, key)
+      let memoizeCache: Partial<State> = {}
+      if (d && d.get) {
+        return {
+          configurable: false,
+          enumerable: true,
+          get() {
+            if (key in memoizeCache) {
+              return memoizeCache[key]
+            }
+            memoizeCache[key] = state[key]
+            return memoizeCache[key]
+          },
+          set(v: typeof value) {
+            return storeDefinition.set(key)(v)
+          }
+        }
+      }
+      return {
+        configurable: false,
+        enumerable: true,
+        get() {
+          return value
+        },
+        set(v: typeof value) {
+          return storeDefinition.set(key)(v)
+        }
+      }
+    }))
+  ))
+}
+
 export type Options = {
   isDevMode: boolean
 }
@@ -54,7 +92,63 @@ let DEFAULT_OPTIONS: Readonly<Options> = {
 }
 
 export class StoreDefinition<State extends object> implements Store<State> {
-  private storeSnapshot: StoreSnapshot<State>
+  private storeSnapshot: State
+  private alls: Emitter<Undux<State>>
+  private emitter: Emitter<State>
+  private setters: {
+    readonly [K in keyof State]: (value: State[K]) => void
+  }
+  constructor(state: State, options: Options) {
+
+    let emitterOptions = {
+      isDevMode: options.isDevMode,
+      onCycle(chain: (string | number | symbol)[]) {
+        console.error(CYCLE_ERROR_MESSAGE + chain.join(' -> '))
+      }
+    }
+
+    // Initialize emitters
+    this.alls = new Emitter(emitterOptions)
+    this.emitter = new Emitter(emitterOptions)
+
+    // Set initial state
+    this.storeSnapshot = StoreSnapshot(state, this)
+
+    // Cache setters
+    this.setters = mapValues(state, (v, key) =>
+      (value: typeof v) => {
+        let previousValue = this.storeSnapshot[key]
+        this.storeSnapshot = StoreSnapshot(Object.assign({}, this.storeSnapshot, { [key]: value }), this)
+        this.emitter.emit(key, value)
+        this.alls.emit(key, { key, previousValue, value })
+      }
+    )
+  }
+  on<K extends keyof State>(key: K): Observable<State[K]> {
+    return this.emitter.on(key)
+  }
+  onAll(): Observable<Undux<State>[keyof State]> {
+    return this.alls.all()
+  }
+  get<K extends keyof State>(key: K) {
+    return this.storeSnapshot[key]
+  }
+  set<K extends keyof State>(key: K): (value: State[K]) => void {
+    return this.setters[key]
+  }
+  getCurrentSnapshot() {
+    return this.storeSnapshot
+  }
+  toStore(): State {
+    return this.storeSnapshot
+  }
+  getState() {
+    return this.storeSnapshot
+  }
+}
+
+export class LegacyStoreDefinition<State extends object> implements Store<State> {
+  private storeSnapshot: LegacyStoreSnapshot<State>
   private alls: Emitter<Undux<State>>
   private emitter: Emitter<State>
   private setters: {
@@ -74,13 +168,13 @@ export class StoreDefinition<State extends object> implements Store<State> {
     this.emitter = new Emitter(emitterOptions)
 
     // Set initial state
-    this.storeSnapshot = new StoreSnapshot(state, this)
+    this.storeSnapshot = new LegacyStoreSnapshot(state, this)
 
     // Cache setters
     this.setters = mapValues(state, (v, key) =>
       (value: typeof v) => {
         let previousValue = this.storeSnapshot.get(key)
-        this.storeSnapshot = new StoreSnapshot(
+        this.storeSnapshot = new LegacyStoreSnapshot(
           Object.assign({}, this.storeSnapshot.getState(), { [key]: value }),
           this
         )

src/react/connect.tsx

@@ -1,12 +1,12 @@
 import * as React from 'react'
 import { Subscription } from 'rxjs'
-import { Store, StoreDefinition, StoreSnapshot } from '../'
+import { LegacyStoreDefinition, LegacyStoreSnapshot, Store } from '../'
 import { Diff, equals, getDisplayName } from '../utils'
 
 /**
  * @deprecated Use `createConnectedStore` instead.
  */
-export function connect<StoreState extends object>(store: StoreDefinition<StoreState>) {
+export function connect<StoreState extends object>(store: LegacyStoreDefinition<StoreState>) {
   return function <
     Props,
     PropsWithStore extends { store: Store<StoreState> } & Props = { store: Store<StoreState> } & Props
@@ -15,7 +15,7 @@ export function connect<StoreState extends object>(store: StoreDefinition<StoreS
   ): React.ComponentClass<Diff<PropsWithStore, { store: Store<StoreState> }>> {
 
     type State = {
-      store: StoreSnapshot<StoreState>
+      store: LegacyStoreSnapshot<StoreState>
       subscription: Subscription
     }
 

src/react/connectAs.tsx

@@ -1,13 +1,13 @@
 import * as React from 'react'
 import { Subscription } from 'rxjs'
-import { StoreDefinition } from '../'
+import { LegacyStoreDefinition } from '../'
 import { Diff, equals, getDisplayName, keys, mapValues, some } from '../utils'
 
 /**
  * @deprecated Use `createConnectedStoreAs` instead.
  */
 export function connectAs<
-  Stores extends {[alias: string]: StoreDefinition<any>}
+  Stores extends {[alias: string]: LegacyStoreDefinition<any>}
 >(
   stores: Stores
 ) {

src/react/createConnectedStore.tsx

@@ -1,15 +1,15 @@
 import * as React from 'react'
 import { Subscription } from 'rxjs'
-import { createStore, Effects, Store, StoreDefinition, StoreSnapshot } from '..'
+import { createStore, Effects, StoreDefinition } from '..'
 import { Diff, getDisplayName } from '../utils'
 
 export type Connect<State extends object> = {
   Container: React.ComponentType<ContainerProps<State>>
   withStore: <
-    Props extends {store: Store<State>}
+    Props extends {store: State}
   >(
     Component: React.ComponentType<Props>
-  ) => React.ComponentType<Diff<Props, {store: Store<State>}>>
+  ) => React.ComponentType<Diff<Props, {store: State}>>
 }
 
 export type ContainerProps<State extends object> = {
@@ -25,7 +25,7 @@ export function createConnectedStore<State extends object>(
 
   type ContainerState = {
     storeDefinition: StoreDefinition<State> | null
-    storeSnapshot: StoreSnapshot<State> | null
+    storeSnapshot: State | null
     subscription: Subscription
   }
 
@@ -67,7 +67,7 @@ export function createConnectedStore<State extends object>(
   }
 
   let Consumer = (props: {
-    children: (store: StoreSnapshot<State>) => JSX.Element
+    children: (store: State) => JSX.Element
     displayName: string
   }) =>
     <Context.Consumer>
@@ -80,8 +80,8 @@ export function createConnectedStore<State extends object>(
     </Context.Consumer>
 
   function withStore<
-    Props extends {store: Store<State>},
-    PropsWithoutStore = Diff<Props, {store: Store<State>}>
+    Props extends {store: State},
+    PropsWithoutStore = Diff<Props, {store: State}>
   >(
     Component: React.ComponentType<Props>
   ): React.ComponentType<PropsWithoutStore> {
@@ -101,7 +101,7 @@ export function createConnectedStore<State extends object>(
 }
 
 function isInitialized<State extends object>(
-  store: StoreSnapshot<State> | {__MISSING_PROVIDER__: true}
+  store: State | {__MISSING_PROVIDER__: true}
 ) {
   return !('__MISSING_PROVIDER__' in store)
 }

src/react/createConnectedStoreAs.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react'
 import { Subscription } from 'rxjs'
-import { createStore, EffectsAs, Store, StoreDefinition, StoreSnapshot } from '..'
+import { createStore, EffectsAs, LegacyStoreSnapshot, Store, StoreDefinition } from '..'
 import { Diff, getDisplayName, mapValues } from '../utils'
 
 export type ConnectAs<States extends {
@@ -35,7 +35,7 @@ export function createConnectedStoreAs<States extends {
       [K in keyof States]: StoreDefinition<States[K]> | null
     }
     storeSnapshots: {
-      [K in keyof States]: StoreSnapshot<States[K]> | null
+      [K in keyof States]: LegacyStoreSnapshot<States[K]> | null
     }
     subscriptions: {
       [K in keyof States]: Subscription
@@ -87,7 +87,7 @@ export function createConnectedStoreAs<States extends {
   }
 
   let Consumer = (props: {
-    children: (stores: { [K in keyof States]: StoreSnapshot<States[K]> }) => JSX.Element
+    children: (stores: { [K in keyof States]: LegacyStoreSnapshot<States[K]> }) => JSX.Element
     displayName: string
   }) =>
     <Context.Consumer>
@@ -122,7 +122,7 @@ export function createConnectedStoreAs<States extends {
 }
 
 function isInitialized<State extends object>(
-  store: StoreSnapshot<State> | {__MISSING_PROVIDER__: true}
+  store: LegacyStoreSnapshot<State> | {__MISSING_PROVIDER__: true}
 ) {
   return !('__MISSING_PROVIDER__' in store)
 }