@farm.js/react 0.1.0-beta.10 → 0.1.0-beta.11

package/README.md

@@ -496,7 +496,11 @@ through one document fragment. It then removes only the replaced window. When th
 has the same length and the same keys in the same order, Farm prepares every binding read and
 changed DOM target across the complete window first, patches the existing rows in place, and
 updates the stored row objects used by later events. That path creates no descriptors or DOM rows,
-and preserves row identity, focus, and selection. A window may instead grow or shrink while it
+and preserves row identity, focus, and selection. Validated same-key row and window refreshes also
+keep the existing row map and element lookup, and skip redundant cache cleanup instead of
+rebuilding whole-list bookkeeping. Source and key validation still run, and each flush commits the
+new collection token for subsequent updates. Structural changes retain index rebuilding and cache
+cleanup. A window may instead grow or shrink while it
 reorders keys from inside its own removed interval and mixes them with globally fresh keys. Farm
 prepares all reused binding updates, new descriptors, binding snapshots, and detached rows before
 the first DOM write. It removes only retired rows, preserves each reused row, batches adjacent new
@@ -562,12 +566,15 @@ subclassed behavior, structural calls after reordering, an unhinted intermediate
 React-owned rows, and failed checks keep complete keyed reconciliation.
 
 A compiler-safe `filter()` or bounded `slice()` prefix may precede the native reorder suffix in a
-concise updater or exact one-return block:
+concise updater or exact one-return block. A filter predicate may be concise or contain exactly one
+direct value-returning `return`:
 
 ```tsx
 setItems((current) =>
   current
-    .filter((item) => item.visible)
+    .filter((item) => {
+      return item.visible;
+    })
     .toSorted((left, right) => left.rank - right.rank)
     .toReversed(),
 );
@@ -809,17 +816,22 @@ setItems((current) => current.filter((item) => item.id !== removedId));
 setItems((current) => {
   return current.filter((item) => item.id !== removedId);
 });
+setItems((current) =>
+  current.filter((item) => {
+    return item.id !== removedId;
+  }),
+);
 ```
 
 For compiler-owned host rows whose render and key do not observe the row index, Farm validates the
 native filter chain, every surviving item identity, and every surviving key before removing only
 the rejected DOM rows. It does not recreate descriptors or reread bindings for unchanged rows,
 and queued filters compose before one compiler flush. Index-aware rows or predicates, updater blocks
-with extra statements, directives, conditional returns, or no value-returning `return`, block-bodied
-predicates, custom filter methods, sparse or subclassed arrays, collection-reading bindings or keys,
-React-owned row structures, mixed dirty dependencies, and failed validation use complete keyed
-reconciliation. No option or new component is required. The compiler report exposes the emitted-site
-count as `keyedArrayFilterHints`.
+with extra statements, directives, conditional returns, or no value-returning `return`, predicate
+blocks with those unsupported shapes, custom filter methods, sparse or subclassed arrays,
+collection-reading bindings or keys, React-owned row structures, mixed dirty dependencies, and
+failed validation use complete keyed reconciliation. No option or new component is required. The
+compiler report exposes the emitted-site count as `keyedArrayFilterHints`.
 
 An otherwise eligible host row may also contain an inline synchronous React event:
 

package/dist/compiler-runtime.cjs

@@ -3381,7 +3381,6 @@ function createHostConditionalBlockComponent(owner) {
       for (const unsubscribe of this.fallbackUnsubscribers) unsubscribe();
       this.fallbackUnsubscribers = [];
       this.instance?.scope?.cleanup();
-      this.root = null;
       this.activeBranch = null;
       this.instance = null;
     }
@@ -3653,7 +3652,6 @@ function createConditionalRangesBlockComponent(owner) {
       for (const unsubscribe of this.fallbackUnsubscribers) unsubscribe();
       this.fallbackUnsubscribers = [];
       for (const instance of this.rangeInstances) instance?.host.scope?.cleanup();
-      this.root = null;
       this.rangeInstances = [];
       this.staticSegments = [];
       this.staticValues.length = 0;
@@ -4495,15 +4493,15 @@ function reconcileCompilerKeyedArrayBatchInsert(props, dirtyState, collectionTok
       return void 0;
     }
   }
-  const knownKeys = new Set(instances.keys());
+  const incomingKeys = /* @__PURE__ */ new Set();
   const incoming = [];
   try {
     for (let offset = 0; offset < insertCount; offset += 1) {
       const index = update.position + offset;
       const item = finalValue[index];
       const key = keyedRowIdentity(props.rowKey(item, index));
-      if (knownKeys.has(key)) return void 0;
-      knownKeys.add(key);
+      if (instances.has(key) || incomingKeys.has(key)) return void 0;
+      incomingKeys.add(key);
       const descriptor = props.create(item, index);
       incoming.push({
         key,
@@ -4656,9 +4654,9 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
       const preparedIncomingKeys = /* @__PURE__ */ new Set();
       const preparedWindows = [];
       const nextInstances = [];
-      for (const window of windows) {
-        if (window[0] < sourceCursor) return void 0;
-        while (sourceCursor < window[0]) {
+      for (const window2 of windows) {
+        if (window2[0] < sourceCursor) return void 0;
+        while (sourceCursor < window2[0]) {
           const instance = previousInstances[sourceCursor];
           if (!instance || instance.index !== sourceCursor || !Object.is(instance.item, finalValue[resultCursor])) {
             return void 0;
@@ -4671,24 +4669,24 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
           props,
           finalValue,
           resultCursor,
-          window[3]
+          window2[3]
         );
         if (!incoming2) return void 0;
-        window[1] = resultCursor;
+        window2[1] = resultCursor;
         const prepared3 = prepareCompilerKeyedArrayWindow(
           props,
           instances,
           previousInstances,
           root,
-          window,
+          window2,
           incoming2,
           preparedIncomingKeys
         );
         if (!prepared3) return void 0;
         preparedWindows.push(prepared3);
         nextInstances.push(...prepared3[4]);
-        sourceCursor += window[2];
-        resultCursor += window[3];
+        sourceCursor += window2[2];
+        resultCursor += window2[3];
       }
       while (sourceCursor < previousInstances.length) {
         const instance = previousInstances[sourceCursor];
@@ -4708,30 +4706,32 @@ function reconcileCompilerKeyedArrayWindowReplace(props, dirtyState, collectionT
       }
       return keyedRowInstancesByKey(nextInstances);
     }
-    const touchedIndices = /* @__PURE__ */ new Set();
-    for (const update2 of updates) {
-      for (let index = update2.position; index < update2.position + update2.removedCount; index += 1) {
-        touchedIndices.add(index);
-      }
-    }
+    updates.sort((left, right) => right.position - left.position);
+    let window = updates.pop();
+    const touchedInstances = [];
     for (let index = 0; index < previousInstances.length; index += 1) {
+      while (window && index >= window.position + window.removedCount) {
+        window = updates.pop();
+      }
       const instance = previousInstances[index];
-      const touched = touchedIndices.has(index);
-      if (!instance || instance.index !== index || (touched ? instance.element.parentNode !== root : !Object.is(instance.item, finalValue[index]))) {
+      if (!instance || instance.index !== index) return void 0;
+      if (window && index >= window.position) {
+        if (instance.element.parentNode !== root) return void 0;
+        touchedInstances.push(instance);
+      } else if (!Object.is(instance.item, finalValue[index])) {
         return void 0;
       }
     }
-    const knownKeys = new Set(instances.keys());
     const incomingKeys2 = /* @__PURE__ */ new Set();
     let replacesRows = false;
     const prepared2 = [];
     try {
-      for (const index of [...touchedIndices].sort((left, right) => left - right)) {
-        const instance = previousInstances[index];
+      for (const instance of touchedInstances) {
+        const index = instance.index;
         const item = finalValue[index];
         const key = keyedRowIdentity(props.rowKey(item, index));
         if (key !== instance.key) {
-          if (knownKeys.has(key) || incomingKeys2.has(key)) return void 0;
+          if (instances.has(key) || incomingKeys2.has(key)) return void 0;
           incomingKeys2.add(key);
           replacesRows = true;
           const descriptor = props.create(item, index);
@@ -5555,11 +5555,13 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
             this.hasReactOwnedRows()
           );
           if (positionedInstances) {
-            this.instances = new Map(positionedInstances);
-            this.rebuildElementIndex(this.instances);
-            const keys = [...this.instances.keys()];
-            this.pruneEventHandlers(keys);
-            this.pruneConditionalListeners(keys);
+            if (positionedInstances !== this.instances) {
+              this.instances = new Map(positionedInstances);
+              this.rebuildElementIndex(this.instances);
+              const keys = [...this.instances.keys()];
+              this.pruneEventHandlers(keys);
+              this.pruneConditionalListeners(keys);
+            }
             this.commitCurrentCollection(dirtyState);
             afterCommit?.();
             return;
@@ -5574,9 +5576,9 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
           );
           if (reorderedInstances) {
             const removedRows = reorderedInstances.size < this.instances.size;
-            this.instances = new Map(reorderedInstances);
-            this.rebuildElementIndex(this.instances);
+            this.instances = reorderedInstances;
             if (removedRows) {
+              this.rebuildElementIndex(this.instances);
               const keys = [...this.instances.keys()];
               this.pruneEventHandlers(keys);
               this.pruneConditionalListeners(keys);
@@ -6303,7 +6305,6 @@ function createKeyedRowsBlockComponent(owner, options = {}) {
     componentWillUnmount() {
       this.mounted = false;
       this.unsubscribe?.();
-      this.root = null;
       this.cleanupHostScopes();
       this.instances.clear();
       this.identityTargets.clear();
@@ -6537,7 +6538,6 @@ function createKeyedRangesBlockComponent(owner) {
     componentWillUnmount() {
       this.mounted = false;
       this.unsubscribe?.();
-      this.root = null;
       this.rangeInstances = [];
       this.staticSegments = [];
       this.staticValues.length = 0;
@@ -6662,7 +6662,6 @@ function createMixedRangesBlockComponent(owner) {
       this.controller?.cleanup();
       this.controller = null;
       this.clearFallbackSubscriptions();
-      this.root = null;
     }
     render() {
       const container = this.currentProps.render();
@@ -7776,13 +7775,11 @@ function createCompiledComponentWithFeatures(definition, runtimeFeatures) {
     }
     componentWillUnmount() {
       this.mounted = false;
-      this.root = null;
       this.dirtyState.clear();
       this.inputSelection = null;
       this.blockRefreshListeners.clear();
       this.blockRoots.clear();
       this.blockRootElements.clear();
-      this.bindingTargets.clear();
       this.bindingTargetRefs.clear();
       this.indexedDefinition = null;
       this.staticBindingsByDependency = [];