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

package/dist/browser/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;
   };
@@ -1786,11 +1805,19 @@ export const makeElementSpine = options => {
         // whatever keeps one copies it or reads it at once.
         const value = running.values(frame.value);
         Object.assign(snapshot.values, value);
-        Object.assign(snapshot.velocities, running.velocities(frame.velocity));
+        // 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));
     }