@lukekaalim/act-recon 3.0.0-alpha.1 → 3.0.0-alpha.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @lukekaalim/act-recon
 
+## 3.0.0-alpha.2
+
+### Patch Changes
+
+- c5e8775: Fix context updates not actually being pushed to the MustRender list
+
 ## 3.0.0-alpha.1
 
 ### Patch Changes

package/element.ts

@@ -7,6 +7,7 @@ import { loadHooks } from "./hooks";
 import { ContextState } from "./context";
 import { ComponentState, EffectID, EffectTask } from "./state";
 import { CommitTree } from "./tree";
+import { addRenderTargetToThread, WorkThread } from "./thread";
 
 /**
  * When processing an element, it may produce additional
@@ -17,19 +18,17 @@ export type ElementOutput = {
   child: Node,
   reject: null | unknown,
   effects: EffectTask[],
-  targets: CommitRef[],
 };
 export const ElementOutput = {
   new: (child: Node): ElementOutput => ({
     child,
     reject: null,
     effects: [],
-    targets: [],
   })
 }
 
 export type ElementService = {
-  render(element: Element, ref: CommitRef): ElementOutput,
+  render(element: Element, ref: CommitRef, thread: WorkThread): ElementOutput,
   clear(ref: Commit): ElementOutput,
 
   boundary: Map<CommitID, unknown>,
@@ -45,6 +44,7 @@ export const createElementService = (
   const render = (
     element: Element,
     ref: CommitRef,
+    thread: WorkThread,
   ): ElementOutput => {
     const output = ElementOutput.new(element.children);
   
@@ -66,7 +66,13 @@ export const createElementService = (
             }
             if (state.value !== element.props.value) {
               state.value = element.props.value;
-              output.targets.push(...state.consumers.values());
+              
+              for (const [, consumer] of state.consumers) {
+                // there should be no way for the children of the
+                // provider to already have been renderer,
+                // so we don't check the return value.
+                addRenderTargetToThread(thread, consumer);
+              }
             }
             break;
           }

package/package.json

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

package/thread.ts

@@ -83,7 +83,7 @@ const updateWorkThread = (thread: WorkThread, update: Update, tree: CommitTree,
   thread.visited.set(ref.id, ref);
   
   if (next) {
-    const output = element.render(next, ref);
+    const output = element.render(next, ref, thread);
     if (output.reject) {
       const errorBoundary = WorkThread.findClosestBoundary(thread, tree, ref);
       if (errorBoundary) {
@@ -158,35 +158,37 @@ const startWorkThreadUpdate = (thread: WorkThread, ref: CommitRef, prev: Commit
 }
 
 /**
- * Request that a commit be re-rendered
+ * For a running thread, add an additional "target" to render,
+ * which forces the thread to VISIT each commit on the path to the target,
+ * and to RENDER the target specifically.
  * 
- * If returns false, the update cannot be queued in the current
- * thread (maybe it already re-rendered?).
- * @param thread 
- * @param ref 
- * @returns 
+ * @param thread
+ * @param target 
+ * @returns `true` if the target was added successfully (or was already in the thread),
+ * or `false` if it could not be added for some reason, such as:
+ *    - The thread has already visited the Commit (a thread will never backtrack)
  */
-const queueWorkThreadTarget = (thread: WorkThread, ref: CommitRef, tree: CommitTree): boolean => {
+export const addRenderTargetToThread = (thread: WorkThread, target: CommitRef): boolean => {
   // If the thread _already_ has this ref as a target,
   // do nothing
-  if (thread.mustRender.has(ref.id))
+  if (thread.mustRender.has(target.id))
     return true;
 
   // We cant do work on a commit that has
   // already been visited
-  if (thread.visited.has(ref.id))
+  if (thread.visited.has(target.id))
     return false;
 
-  thread.reasons.push({ type: 'target', ref });
-  thread.mustRender.set(ref.id, ref);
+  thread.reasons.push({ type: 'target', ref: target });
+  thread.mustRender.set(target.id, target);
 
   // Search through all the parents, looking to see if
   // there are any pendingUpdates that might
   // lead to this commit. If so, make sure ancestor commit
   // is on the MustVisit so they should make their way down
   // eventually
-  for (let i = ref.path.length - 1; i >= 0; i--) {
-    const id = ref.path[i];
+  for (let i = target.path.length - 1; i >= 0; i--) {
+    const id = target.path[i];
     thread.mustVisit.add(id);
 
     for (const update of thread.pendingUpdates) {
@@ -196,6 +198,24 @@ const queueWorkThreadTarget = (thread: WorkThread, ref: CommitRef, tree: CommitT
         return true;
     }
   }
+
+  return true;
+}
+
+/**
+ * Request that a commit be re-rendered
+ * 
+ * If returns false, the update cannot be queued in the current
+ * thread (maybe it already re-rendered?).
+ * @param thread 
+ * @param ref 
+ * @returns 
+ */
+const queueWorkThreadTarget = (thread: WorkThread, ref: CommitRef, tree: CommitTree): boolean => {
+  // Try to add to the thread
+  if (!addRenderTargetToThread(thread, ref)) {
+    return false;
+  }
   // otherwise, start a new update from the root
   const prev = tree.commits.get(ref.id) as Commit;
   startWorkThreadUpdate(thread, ref, prev, prev.element);