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

package/src/spine.ts

@@ -16,7 +16,7 @@
  */
 import * as BaseValue from "@wardic/core/BaseValue"
 import type * as DefaultTransition from "@wardic/core/DefaultTransition"
-import type * as Frame from "@wardic/core/Frame"
+import * as Frame from "@wardic/core/Frame"
 import type * as FrameLoop from "@wardic/core/FrameLoop"
 import * as InterpolatorRegistry from "@wardic/core/InterpolatorRegistry"
 import * as Machine from "@wardic/core/Machine"
@@ -534,8 +534,6 @@ interface Running extends Machine.RunOptions {
   count: number
   /** A frame's values for the keys it still draws: the frame's own while it draws all of them. */
   values: (value: Values.Values) => Values.Values
-  /** The same, for a frame's velocities. */
-  velocities: (velocity: Readonly<Record<string, number>>) => Readonly<Record<string, number>>
   /** It drew its last frame: its keys landed. */
   done: boolean
   /** It gave up a key in this Retarget: what it still draws is worked out at the Retarget's end. */
@@ -555,6 +553,11 @@ interface Running extends Machine.RunOptions {
   last: Values.Values | undefined
   before: Values.Values | undefined
   beforeAt: number
+  /**
+   * A Numbers leg's last Frame (#663): its keys' velocities are read from it when one is asked for, as
+   * a Blend leg's are from its frames, by index from a spring's. None before its first frame.
+   */
+  physics: Frame.MultiPhysics | undefined
 }
 
 /** No running legs. */
@@ -741,7 +744,6 @@ const runningOf = (to: Values.Values, resolution: Resolution, landing: Landing,
   resolution,
   count: 0,
   values: identity,
-  velocities: identity,
   done: false,
   losing: false,
   fiber: undefined,
@@ -755,6 +757,7 @@ const runningOf = (to: Values.Values, resolution: Resolution, landing: Landing,
   last: undefined,
   before: undefined,
   beforeAt: Number.NEGATIVE_INFINITY,
+  physics: undefined,
 })
 
 /**
@@ -1647,13 +1650,19 @@ export interface Snapshot {
   owners: ReadonlyMap<string, Running | undefined> | undefined
   /** The time now, its provider's Clock's once its spine runs (#460, Q7), {@link frameNow} before. */
   now: () => number
+  /**
+   * Every numeric key's velocity now (#663), given the Snapshot: {@link velocitiesNowOf}, one function
+   * every Snapshot shares. A resolver and Animation controls read these: `velocities` doesn't hold a
+   * spring leg's. A method, so a Snapshot is a resolver's `VariantState`.
+   */
+  velocitiesNow(snapshot: Snapshot): Readonly<Record<string, number>>
 }
 
 /** A Snapshot seeded from the Starting values, velocities 0, so frame 1 flows out of the seed (no snap). */
 export const snapshotOf = (start: Start): Snapshot => emptySnapshotOf({ ...start.initialValues })
 
 /** A Snapshot of `values`, nothing moving: read as it is until a spine reads it. */
-export const emptySnapshotOf = (values: Values.Values): Snapshot => ({ values, velocities: {}, drawnAt: {}, owners: undefined, now: frameNow })
+export const emptySnapshotOf = (values: Values.Values): Snapshot => ({ values, velocities: {}, drawnAt: {}, owners: undefined, now: frameNow, velocitiesNow: velocitiesNowOf })
 
 // --- Velocities (#464) ---------------------------------------------------------------------------
 
@@ -1661,9 +1670,28 @@ export const emptySnapshotOf = (values: Values.Values): Snapshot => ({ values, v
 const legVelocityOf = (snapshot: Snapshot, running: Running, key: string): number => {
   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: Snapshot, running: Running, key: string): number => {
+  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
@@ -2155,7 +2183,6 @@ export const makeElementSpine = (options: ElementSpineOptions): ElementSpine =>
       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
   }
@@ -2223,13 +2250,24 @@ export const makeElementSpine = (options: ElementSpineOptions): ElementSpine =>
           // 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)
       )

package/src/unstable/v2/ward.tsx

@@ -1103,6 +1103,13 @@ export function wardWith(config: WardConfig, internal: WardInternals): Ward {
   // The Override stack, compared by value: a change that resolves the same target doesn't Retarget.
   // A keyboard lift turns `whileDrag` on, as a drag does (ADR-0037).
   const lifted = UndefinedOr.match(internal.lifted, { onUndefined: () => constFalse, onDefined: identity })
+  // The target reads the lift through a boundary (#666): an item with no `whileDrag` of its own
+  // resolves the same lifted or not (a dragged parent's name hands down with its own drag on), so
+  // every lift and drop re-ran its target for nothing. A Reorder item's alone: no other ward lifts.
+  const liftedLayer = UndefinedOr.match(internal.lifted, {
+    onUndefined: () => constFalse,
+    onDefined: (isLifted) => createMemo(() => Predicate.isNotUndefined(cfg().whileDrag) && isLifted(), CLIENT_ONLY),
+  })
   const target = createMemo<Resolution>(
     () => {
       const g = gestures()
@@ -1115,7 +1122,7 @@ export function wardWith(config: WardConfig, internal: WardInternals): Ward {
           focused: g.focused,
           hovered: g.hovered,
           pressed: g.pressed,
-          dragged: Bool.or(g.dragging, lifted()),
+          dragged: Bool.or(g.dragging, liftedLayer()),
           dragging: g.dragging,
         },
         snapshot,

package/src/variant-target.ts

@@ -23,6 +23,8 @@ import type { WardicTransition, WardicVariant, WardicVariantLabels, WardicVarian
 export interface VariantState {
   readonly values: Readonly<Record<string, number | string>>
   readonly velocities: Readonly<Record<string, number>>
+  /** The velocities now, worked out when read (#663): a Snapshot's, whose spring legs' aren't in `velocities`. */
+  velocitiesNow?(state: VariantState): Readonly<Record<string, number>>
 }
 
 /** No values yet: a server render's, and the Starting style's. */
@@ -87,9 +89,13 @@ export interface NamedTarget extends Target {
 /** What a variant name, a variants entry or a resolver's result can be. */
 type Definition = WardicVariant | WardicVariantResolver | string | undefined
 
+/** A state's velocities now (#663): worked out where it can, else as it holds them. Per resolver call. */
+const velocitiesOf = (state: VariantState): Readonly<Record<string, number>> =>
+  UndefinedOr.match(state.velocitiesNow, { onUndefined: () => state.velocities, onDefined: (now) => now(state) })
+
 /** A resolver called with what it reads, as Motion calls it; anything else as it is. */
 const calledOf = (definition: Definition, custom: unknown, state: VariantState): Definition => {
-  if (Predicate.isFunction(definition)) return definition(custom, { ...state.values }, { ...state.velocities })
+  if (Predicate.isFunction(definition)) return definition(custom, { ...state.values }, { ...velocitiesOf(state) })
   return definition
 }