@lukekaalim/act-recon 2.0.0 → 3.0.0-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @lukekaalim/act-recon
 
+## 3.0.0-alpha.0
+
+### Major Changes
+
+- b3f6c49: Added debug capabilities and protocol
+
 ## 2.0.0
 
 ### Major Changes

package/event.ts

@@ -1,34 +1,30 @@
 export type Subscription = { cancel: () => void };
 export type EventHandler<T> = (event: T) => unknown; 
-export type EventMap = Record<string, unknown>;
 
-export type EventEmitter<T extends EventMap> = {
-  on<K extends keyof T>(type: K, handler: EventHandler<T[K]>): Subscription,
-  call<K extends keyof T>(type: K, event: T[K]): void;
-}
+export type EventEmitter<T> = {
+  subscribe(handler: EventHandler<T>): Subscription,
+  emit(event: T): void;
+};
 
-export const createEventEmitter = <T extends EventMap>(): EventEmitter<T> => {
-  type AnyEvent = T[keyof T];
-  type AnyHandler = EventHandler<AnyEvent>
-  const handlers = new Map<keyof T, Set<AnyHandler>>();
+export const createEventEmitter = <T>(): EventEmitter<T> => {
+  const handlers = new Map<number, EventHandler<T>>();
+  let counter = 0;
 
   return {
-    on(type, handler) {
-      const set = handlers.get(type) || new Set<AnyHandler>();
-      handlers.set(type, set);
-      set.add(handler as AnyHandler);
+    subscribe(handler) {
+      const id = counter++;
+      handlers.set(id, handler);
       return {
         cancel() {
-          set.delete(handler as AnyHandler);
+          handlers.delete(id);
         },
       }
     },
-    call(type, event) {
-      const set = handlers.get(type);
-      if (!set)
-        return;
-      for (const handler of set)
-        handler(event);
+    emit(event) {
+      for (const handler of handlers.values())
+        try {
+          handler(event);
+        } finally {}
     },
   }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lukekaalim/act-recon",
   "type": "module",
-  "version": "2.0.0",
+  "version": "3.0.0-alpha.0",
   "main": "mod.ts",
   "dependencies": {
     "@lukekaalim/act": "^3.2.0"

package/reconciler.ts

@@ -13,7 +13,7 @@ export type Reconciler = {
   state: ReconcilerState,
   tree: CommitTree,
   elements: ElementService,
-  on: EventEmitter<ReconcilerEvents>["on"],
+  subscribe: EventEmitter<ReconcilerEvent>["subscribe"],
 }
 
 export type ReconcilerState = {
@@ -25,14 +25,15 @@ export type ReconcilerState = {
   pendingTargets: Map<CommitID, CommitRef>,
 }
 
-export type ReconcilerEvents = {
-  'on-thread-start': WorkThread,
-  'on-thread-update': WorkThread,
-  'on-thread-complete': WorkThread,
-}
+export type ReconcilerEvent =
+  | { type: 'thread:start', thread: WorkThread }
+  | { type: 'thread:update', thread: WorkThread }
+  | { type: 'thread:complete', thread: WorkThread }
+  | { type: 'thread:new-target', thread: WorkThread }
+  | { type: 'thread:new-root', thread: WorkThread }
 
 export const createReconciler = (scheduler: Scheduler): Reconciler => {
-  const events = createEventEmitter<ReconcilerEvents>();
+  const events = createEventEmitter<ReconcilerEvent>();
   const state: ReconcilerState = {
     thread: null,
     work: null,
@@ -59,7 +60,7 @@ export const createReconciler = (scheduler: Scheduler): Reconciler => {
         render(target);
 
       WorkThread.apply(completedThread, tree);
-      events.call('on-thread-complete', completedThread);
+      events.emit({ type: 'thread:complete', thread: completedThread });
 
       // Run side effects
       for (const effect of completedThread.pendingEffects) {
@@ -75,7 +76,7 @@ export const createReconciler = (scheduler: Scheduler): Reconciler => {
   const start = () => {
     if (!state.thread) {
       state.thread = WorkThread.new();
-      events.call('on-thread-start', state.thread);
+      events.emit({ type: 'thread:start', thread: state.thread });
     }
     if (!state.work) {
       state.work = scheduler.requestWork(work);
@@ -92,13 +93,13 @@ export const createReconciler = (scheduler: Scheduler): Reconciler => {
       tree.roots.add(ref);
       WorkThread.queueMount(thread, ref, element);
     }
-    events.call('on-thread-update', thread);
+    events.emit({ type: 'thread:new-root', thread });
   };
   const render = (ref: CommitRef) => {
     const thread = start();
 
     if (WorkThread.queueTarget(thread, ref, tree)) {
-      events.call('on-thread-update', thread);
+      events.emit({ type: 'thread:new-target', thread });
     } else {
       state.pendingTargets.set(ref.id, ref);
     }
@@ -107,5 +108,5 @@ export const createReconciler = (scheduler: Scheduler): Reconciler => {
   const tree = CommitTree.new();
   const elements = ElementService.create(tree, render);
 
-  return { mount, render, state, tree, elements, on: events.on };
+  return { mount, render, state, tree, elements, subscribe: events.subscribe };
 }