feat(core): bean force update (#40)

* feat(core): supports bean force update

* chore(npm): version 0.1.3-beta

package.json

@@ -1,6 +1,6 @@
 {
   "name": "stated-bean",
-  "version": "0.1.2-RC.4",
+  "version": "0.1.3-beta",
   "repository": "[email protected]:mjolnirjs/stated-bean.git",
   "license": "MIT",
   "main": "dist/cjs",

src/core/ForceUpdate.ts

@@ -0,0 +1 @@
+export const ForceUpdate = Symbol('stated-bean-force-update');

src/core/StatedBeanContainer.ts

@@ -4,6 +4,7 @@ import { getMetadataStorage } from '../metadata';
 
 import { StatedBeanApplication } from './StatedBeanApplication';
 import { EffectContext } from './EffectContext';
+import { ForceUpdate } from './ForceUpdate';
 
 export class StatedBeanContainer extends Event {
   private readonly _parent?: StatedBeanContainer;
@@ -75,11 +76,12 @@ export class StatedBeanContainer extends Event {
       return;
     }
 
+    this.addForceUpdate(bean, beanMeta);
+
     const fields = beanMeta.statedFields || [];
     const observers = (fields || []).map(field =>
       this.observeBeanField(bean, field, beanMeta),
     );
-
     await Promise.all(observers);
 
     if (
@@ -91,6 +93,32 @@ export class StatedBeanContainer extends Event {
     }
   }
 
+  addForceUpdate<T>(bean: T, beanMeta: StatedBeanMeta) {
+    const self = this;
+    Object.defineProperty(bean, ForceUpdate, {
+      value: function(field: keyof T & string) {
+        if (bean[field] === undefined) {
+          return;
+        }
+        const fieldMeta = (beanMeta.statedFields || []).find(
+          f => f.name === field,
+        );
+        if (fieldMeta === undefined) {
+          return;
+        }
+        const effect = self.createEffectContext(
+          bean[field],
+          bean,
+          beanMeta,
+          fieldMeta,
+          bean[field],
+        );
+
+        self.emit(bean, effect);
+      },
+    });
+  }
+
   async observeBeanField(
     bean: any,
     fieldMeta: StatedFieldMeta,
@@ -123,11 +151,13 @@ export class StatedBeanContainer extends Event {
           value,
         );
 
-        bean[proxyField] = effect.getValue();
+        bean[proxyField] = value;
         self.application.interceptStateChange(effect).then(() => {
-          bean[proxyField] = effect.getValue();
+          if (effect.getValue() !== value) {
+            bean[proxyField] = effect.getValue();
+          }
           // console.log(bean.constructor.name + '_changed');
-          self.emit(beanMeta.target, effect);
+          self.emit(bean, effect);
         });
       },
       get() {

src/core/index.ts

@@ -3,3 +3,4 @@ export * from './StatedBeanApplication';
 export * from './StatedBeanContainer';
 export * from './StatedBeanFactory';
 export * from './StatedBeanScope';
+export * from './ForceUpdate';

src/event/Event.ts

@@ -1,22 +1,24 @@
+import { ClassType } from '../types';
+
 type EventListenFn = (...args: any) => void;
-type EventTypes = WeakMap<Function, EventListenFn[]>;
+type EventTypes = WeakMap<InstanceType<ClassType>, EventListenFn[]>;
 
 export class Event {
   events: EventTypes = new WeakMap();
 
-  on(type: Function, cb: EventListenFn) {
+  on(type: InstanceType<ClassType>, cb: EventListenFn) {
     this.events.set(type, (this.events.get(type) || []).concat(cb));
   }
 
-  emit(type: Function, ...data: any) {
+  emit(type: InstanceType<ClassType>, ...data: any) {
     if (this.events.has(type)) {
       this.events.get(type)!.forEach(cb => {
         cb(...data);
       });
     }
   }
 
-  off(type: Function, cb: EventListenFn) {
+  off(type: InstanceType<ClassType>, cb: EventListenFn) {
     if (this.events.has(type)) {
       this.events.set(type, this.events.get(type)!.filter(c => c !== cb));
     }

src/hooks/useStatedBean.ts

@@ -48,9 +48,6 @@ export function useStatedBean<T extends ClassType>(
       container.register(type);
     }
 
-    if (container !== undefined) {
-      container.on(type, beanChangeListener);
-    }
     return container;
   });
 
@@ -59,7 +56,11 @@ export function useStatedBean<T extends ClassType>(
   }
 
   const [bean] = useState(() => {
-    return container.getBean<InstanceType<T>>(type);
+    const bean = container.getBean<InstanceType<T>>(type);
+    if (container !== undefined) {
+      container.on(bean, beanChangeListener);
+    }
+    return bean;
   });
 
   if (bean === undefined) {