@farm.js/react 0.1.0-beta.6 → 0.1.0-beta.7

package/README.md

@@ -300,19 +300,25 @@ expose the site count as `keyedArrayRollingWindowHints`.
 Native known-position updates can avoid a complete keyed scan too:
 
 ```tsx
-setItems((current) => current.toSpliced(500, 0, nextItem));
-setItems((current) => current.with(500, replacement));
+setItems((current) => current.toSpliced(selectedIndex, 0, nextItem));
+setItems((current) => current.toSpliced(selectedIndex, 1));
+setItems((current) => current.with(selectedIndex, replacement));
 ```
 
-The compiler recognizes only a concise functional setter, a build-time safe-integer position, one
-inserted item with zero removals, or one direct replacement. Farm preserves the ordinary native
-method call and records metadata only after validating the committed native source and result. The
-runtime creates one inserted row or patches/replaces one row at the known position without
-rereading every existing key, descriptor, and binding. Index-aware or collection-reading rows,
-custom methods, other `toSpliced()` forms, block-bodied updaters, unsafe incoming expressions,
-queued uncommitted updates, reused keys, nested or React-owned rows, and failed checks use complete
-keyed reconciliation. Reports expose the site count as `keyedArrayPositionHints`; the capability is
-tree-shaken from modules that do not emit it.
+The compiler recognizes only a concise functional setter and either a safe-integer literal or a
+compiler-safe runtime position expression, such as an identifier, property read, arithmetic,
+conditional, or safe `Math` call. The update must insert one item with zero removals, remove one
+item, or directly replace one item. Farm preserves method lookup, evaluates the position and
+remaining arguments once in their original order, executes the ordinary native call, and records
+metadata only after validating the committed native source, result, and actual safe-integer
+position. The runtime creates one inserted row, removes one known row, or patches/replaces one row
+at that position without rereading every existing key, descriptor, and binding. Surviving rows keep
+their DOM identity. Index-aware or collection-reading rows, custom methods, position expressions
+with user calls or mutations, runtime positions that are not safe integers, other `toSpliced()`
+forms, block-bodied updaters, unsafe incoming expressions, queued uncommitted updates, reused keys,
+nested or React-owned rows, and failed checks use complete keyed reconciliation. Reports expose the
+site count as `keyedArrayPositionHints`; the capability is tree-shaken from modules that do not emit
+it.
 
 A direct native reverse can carry its complete permutation to a separate optional runtime:
 
@@ -330,6 +336,26 @@ React-owned rows, and failed checks keep complete keyed reconciliation. Reports
 count as `keyedArrayReorderHints`, and modules without one omit the reorder runtime. Farm does not
 polyfill `Array.prototype.toReversed`.
 
+A direct native immutable sort can use the same optional reorder runtime:
+
+```tsx
+setItems((current) => current.toSorted((left, right) => left.rank - right.rank));
+setLabels((current) => current.toSorted());
+```
+
+Farm recognizes a concise functional setter with no comparator or an inline synchronous comparator
+from the compiler-safe expression subset. It preserves the original method lookup, comparator,
+stable native result, and errors. After the native sort runs, the runtime validates a committed
+ordinary dense array, equal lengths, and a unique one-to-one item-identity permutation. It then
+uses LIS to move only `n - LIS` keyed DOM nodes without rereading row keys, descriptors, or
+bindings. The native sorting work itself is unchanged.
+
+Index-aware or collection-reading rows, referenced comparators, block-bodied updaters, computed or
+chained calls, custom methods, sparse or subclassed arrays, duplicate item identities, queued
+uncommitted sorts, nested or React-owned rows, and failed checks keep complete keyed
+reconciliation. Reports expose the site count as `keyedArraySortHints`; sort shares the optional
+reorder runtime, and Farm does not polyfill `Array.prototype.toSorted`.
+
 Concise immutable filters on a direct keyed array can carry removal positions into the same
 optional runtime:
 
@@ -631,9 +657,10 @@ reasons aggregated by count. Its summary and per-module `optimizations` also rep
 `keyedArrayAppendHints`, the number of compiler-proven direct keyed-array append sites; and
 `keyedArrayFilterHints`, the number of compiler-proven direct keyed-array filter sites; and
 `keyedArrayPrependHints`, the number of compiler-proven direct keyed-array prepend sites; and
-`keyedArrayPositionHints`, the number of compiler-proven native known-position insertion or
-replacement sites; and
+`keyedArrayPositionHints`, the number of compiler-proven native exact-position insertion, removal,
+or replacement sites, including guarded compiler-safe runtime positions; and
 `keyedArrayReorderHints`, the number of compiler-proven direct native keyed-array reverse sites; and
+`keyedArraySortHints`, the number of compiler-proven direct native keyed-array sort sites; and
 `keyedArrayRollingWindowHints`, the number of compiler-proven retained-tail plus incoming-suffix
 sites; and
 `keyedArraySliceHints`, the number of compiler-proven direct keyed-array slice sites. A custom

package/dist/compiler-runtime.cjs

@@ -43,6 +43,7 @@ var NATIVE_ARRAY_SLICE = Array.prototype.slice;
 var NATIVE_ARRAY_TO_SPLICED = Array.prototype.toSpliced;
 var NATIVE_ARRAY_WITH = Array.prototype.with;
 var NATIVE_ARRAY_TO_REVERSED = Array.prototype.toReversed;
+var NATIVE_ARRAY_TO_SORTED = Array.prototype.toSorted;
 var NATIVE_REFLECT_APPLY = Reflect.apply;
 function compilerObject(value) {
   return typeof value === "object" && value !== null || typeof value === "function" ? value : void 0;
@@ -163,7 +164,7 @@ function compilerKeyedArrayPosition(value, sourceToken, expectedLength) {
   const target = compilerObject(value);
   if (!target || !sourceToken || !Array.isArray(value)) return void 0;
   const update = COMPILER_KEYED_ARRAY_POSITIONS.get(target);
-  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.position < 0 || update.position > expectedLength || update.kind === "insert" && update.resultLength !== expectedLength + 1 || update.kind === "replace" && (update.position >= expectedLength || update.resultLength !== expectedLength)) {
+  if (!update || update.sourceToken !== sourceToken || update.sourceLength !== expectedLength || update.resultLength !== value.length || update.position < 0 || update.position > expectedLength || update.kind === "insert" && update.resultLength !== expectedLength + 1 || update.kind === "remove" && (update.position >= expectedLength || update.resultLength !== expectedLength - 1) || update.kind === "replace" && (update.position >= expectedLength || update.resultLength !== expectedLength)) {
     return void 0;
   }
   return update;
@@ -380,8 +381,9 @@ function createCompilerKeyedArrayPositionUpdate(previous, method, kind, position
     const sourceLength = previous.length;
     const normalizedPosition = position < 0 ? Math.max(sourceLength + position, 0) : Math.min(position, sourceLength);
     const validInsert = kind === "insert" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 2 && Object.is(args[0], 0) && value.length === sourceLength + 1;
+    const validRemove = kind === "remove" && method === NATIVE_ARRAY_TO_SPLICED && args.length === 1 && Object.is(args[0], 1) && normalizedPosition < sourceLength && value.length === sourceLength - 1;
     const validReplace = kind === "replace" && method === NATIVE_ARRAY_WITH && args.length === 1 && position >= -sourceLength && position < sourceLength && value.length === sourceLength;
-    if (!validInsert && !validReplace) return value;
+    if (!validInsert && !validRemove && !validReplace) return value;
     const sourceToken = compilerKeyedCollectionToken(previousTarget);
     if (!sourceToken) return value;
     COMPILER_KEYED_ARRAY_POSITIONS.set(valueTarget, {
@@ -419,6 +421,33 @@ function createCompilerKeyedArrayReorder(previous, method) {
   }
   return value;
 }
+function createCompilerKeyedArraySort(previous, method, ...args) {
+  const value = NATIVE_REFLECT_APPLY(
+    method,
+    previous,
+    args
+  );
+  try {
+    const previousTarget = compilerObject(previous);
+    const valueTarget = compilerObject(value);
+    if (!previousTarget || !valueTarget || !COMPILER_KEYED_COMMITTED_COLLECTIONS.has(previousTarget) || !Array.isArray(previous) || !Array.isArray(value) || Object.getPrototypeOf(previous) !== NATIVE_ARRAY_PROTOTYPE || Object.getPrototypeOf(value) !== NATIVE_ARRAY_PROTOTYPE || method !== NATIVE_ARRAY_TO_SORTED || args.length > 1 || args.length === 1 && args[0] !== void 0 && typeof args[0] !== "function" || value.length !== previous.length) {
+      return value;
+    }
+    for (let index = 0; index < previous.length; index += 1) {
+      if (!(index in previous)) return value;
+    }
+    const sourceToken = compilerKeyedCollectionToken(previousTarget);
+    if (!sourceToken) return value;
+    COMPILER_KEYED_ARRAY_REORDERS.set(valueTarget, {
+      kind: "sort",
+      sourceToken,
+      sourceLength: previous.length,
+      resultLength: value.length
+    });
+  } catch {
+  }
+  return value;
+}
 function applyCompilerKeyedCollectionMutation(collection, method, operation, key, value) {
   const args = operation === "map-set" ? [key, value] : [key];
   const result = NATIVE_REFLECT_APPLY(method, collection, args);
@@ -2758,6 +2787,16 @@ function reconcileCompilerKeyedArrayPosition(props, dirtyState, collectionToken,
   if (!update || !Array.isArray(finalValue)) return void 0;
   const previousInstances = [...instances.values()];
   const previous = previousInstances[update.position];
+  if (update.kind === "remove") {
+    if (!previous || previous.index !== update.position) return void 0;
+    previous.scope?.cleanup();
+    previous.element.remove();
+    previousInstances.splice(update.position, 1);
+    for (let index = update.position; index < previousInstances.length; index += 1) {
+      previousInstances[index].index = index;
+    }
+    return new Map(previousInstances.map((instance) => [instance.key, instance]));
+  }
   let item;
   let key;
   try {
@@ -2834,8 +2873,47 @@ function reconcileCompilerKeyedArrayReorder(props, dirtyState, collectionToken,
   }
   const finalValue = props.items();
   const update = compilerKeyedArrayReorder(finalValue, collectionToken, instances.size);
-  if (!update || update.kind !== "reverse" || !Array.isArray(finalValue)) return void 0;
+  if (!update || !Array.isArray(finalValue)) return void 0;
   const previousInstances = [...instances.values()];
+  if (update.kind === "sort") {
+    const instancesByItem = /* @__PURE__ */ new Map();
+    try {
+      for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
+        const instance = previousInstances[sourceIndex];
+        if (instance.index !== sourceIndex || instancesByItem.has(instance.item)) return void 0;
+        instancesByItem.set(instance.item, instance);
+      }
+      const nextInstances = [];
+      const sequence = [];
+      for (let targetIndex = 0; targetIndex < finalValue.length; targetIndex += 1) {
+        const item = finalValue[targetIndex];
+        const instance = instancesByItem.get(item);
+        if (!instance || !Object.is(instance.item, item)) return void 0;
+        instancesByItem.delete(item);
+        nextInstances.push(instance);
+        sequence.push(instance.index);
+      }
+      if (instancesByItem.size > 0) return void 0;
+      const activeElement2 = root.ownerDocument.activeElement;
+      const restoreFocus2 = Boolean(activeElement2 && root.contains(activeElement2));
+      const stablePositions = longestIncreasingSubsequencePositions(sequence);
+      let anchor2 = null;
+      for (let index = nextInstances.length - 1; index >= 0; index -= 1) {
+        const instance = nextInstances[index];
+        if (!stablePositions.has(index) && instance.element.nextSibling !== anchor2) {
+          root.insertBefore(instance.element, anchor2);
+        }
+        anchor2 = instance.element;
+        instance.index = index;
+      }
+      if (restoreFocus2 && activeElement2?.isConnected && activeElement2.ownerDocument.activeElement !== activeElement2 && "focus" in activeElement2) {
+        activeElement2.focus({ preventScroll: true });
+      }
+      return new Map(nextInstances.map((instance) => [instance.key, instance]));
+    } catch {
+      return void 0;
+    }
+  }
   try {
     for (let sourceIndex = 0; sourceIndex < previousInstances.length; sourceIndex += 1) {
       const instance = previousInstances[sourceIndex];
@@ -5147,6 +5225,7 @@ exports.createCompilerKeyedArrayPrepend = createCompilerKeyedArrayPrepend;
 exports.createCompilerKeyedArrayReorder = createCompilerKeyedArrayReorder;
 exports.createCompilerKeyedArrayRollingWindow = createCompilerKeyedArrayRollingWindow;
 exports.createCompilerKeyedArraySlice = createCompilerKeyedArraySlice;
+exports.createCompilerKeyedArraySort = createCompilerKeyedArraySort;
 exports.createCompilerKeyedCollectionUpdate = createCompilerKeyedCollectionUpdate;
 exports.createCompilerKeyedMapUpdate = createCompilerKeyedMapUpdate;
 exports.hostConditionalRuntimeFeature = hostConditionalRuntimeFeature;