@wardic/solid 1.0.0-rc.6 → 1.0.0-rc.8

package/dist/server/spine.js

@@ -15,6 +15,7 @@
  * @module
  */
 import * as BaseValue from "@wardic/core/BaseValue";
+import * as Frame from "@wardic/core/Frame";
 import * as InterpolatorRegistry from "@wardic/core/InterpolatorRegistry";
 import * as Machine from "@wardic/core/Machine";
 import * as Override from "@wardic/core/Override";
@@ -484,7 +485,6 @@ const runningOf = (to, resolution, landing, kind) => ({
   resolution,
   count: 0,
   values: identity,
-  velocities: identity,
   done: false,
   losing: false,
   fiber: undefined,
@@ -497,7 +497,8 @@ const runningOf = (to, resolution, landing, kind) => ({
   lastAt: Number.NEGATIVE_INFINITY,
   last: undefined,
   before: undefined,
-  beforeAt: Number.NEGATIVE_INFINITY
+  beforeAt: Number.NEGATIVE_INFINITY,
+  physics: undefined
 });
 /**
  * A Blend leg's velocity for `key` (#464, Motion's `getVelocity`): its last two frames' change over
@@ -1318,15 +1319,34 @@ export const emptySnapshotOf = values => ({
   velocities: {},
   drawnAt: {},
   owners: undefined,
-  now: frameNow
+  now: frameNow,
+  velocitiesNow: velocitiesNowOf
 });
 // --- Velocities (#464) ---------------------------------------------------------------------------
 /** A leg's velocity for `key`: a Blend leg's from its frames, a Snap's none, a spring's or a follow's as it wrote it. */
 const legVelocityOf = (snapshot, running, key) => {
   if (running.kind === "Blend") return blendVelocityOf(running, key);
   if (running.kind === "Snap") return 0;
+  if (running.kind === "Numbers") return numbersVelocityOf(snapshot, running, key);
   return velocityOf(snapshot, key);
 };
+/**
+ * A Numbers leg's velocity for `key` (#663): its last Frame's, as it drew it, by index from a spring's
+ * (whose velocity record it doesn't write), from the record of an inertia's; the Snapshot's before its
+ * first frame, or for a key its Frame doesn't have. Per key, per Retarget: guards.
+ */
+const numbersVelocityOf = (snapshot, running, key) => {
+  const last = running.physics;
+  if (Predicate.isUndefined(last)) return velocityOf(snapshot, key);
+  if (Frame.isSpringValues(last)) {
+    const at = last.keys.indexOf(key);
+    if (at < 0) return velocityOf(snapshot, key);
+    return UndefinedOr.getOrThrow(last.velocities[at]);
+  }
+  const velocity = last.velocity[key];
+  if (Predicate.isUndefined(velocity)) return velocityOf(snapshot, key);
+  return velocity;
+};
 /**
  * `key`'s velocity at `now` (#464, Motion's `getVelocity`): the leg drawing it, once it has drawn a
  * frame, else what the Snapshot holds for it (the last leg to let it go left it, a drag or a seed set
@@ -1718,7 +1738,6 @@ export const makeElementSpine = options => {
       if (running.count === 0) return;
       const kept = Arr.filter(Rec.keys(running.targets), key => owners.get(key) === running);
       running.values = keepingOnly(kept);
-      running.velocities = keepingOnly(kept);
     });
     losing.length = 0;
   };
@@ -1781,19 +1800,24 @@ export const makeElementSpine = options => {
         // rather than replacing it, so the drag's direct-set x/y survive alongside the
         // spring's keys (drag owns x/y, spring owns the rest) and the post-drag
         // handoff continues from the rested position. Only the keys it still draws (#325).
+        // In place, as the Follow sink writes (#659): a spread made two records per element per
+        // frame. The Snapshot's records are always its own (`snapshotOf`, `emptySnapshotOf`), and
+        // whatever keeps one copies it or reads it at once.
         const value = running.values(frame.value);
-        snapshot.values = {
-          ...snapshot.values,
-          ...value
-        };
-        snapshot.velocities = {
-          ...snapshot.velocities,
-          ...running.velocities(frame.velocity)
-        };
+        Object.assign(snapshot.values, value);
+        // Its velocities stay on its Frame (#663), read by index when one is asked for: copied into
+        // the Snapshot each frame, they cost a boxed number a key a frame that only a Retarget read.
+        running.physics = frame;
         gate.write(id, value);
         recordFrame(value);
         drew(running, frame.done, snapshot.now());
-        if (frame.done) landEndsOf(waiting);
+        if (frame.done) {
+          // Landed, its keys are at rest: the Snapshot says so for whatever reads it after it's gone.
+          Arr.forEach(Rec.keys(value), key => {
+            snapshot.velocities[key] = 0;
+          });
+          landEndsOf(waiting);
+        }
         return undefined;
       }, running));
     }