@rafaelaugusto/jolt 0.1.0-beta.12 → 0.1.0-beta.13

package/src/value-observers.ts

@@ -0,0 +1,133 @@
+import { Application, Color, Trace } from '@nativescript/core'
+import { getDriver } from './driver/index.js'
+
+export interface SubscribeOptions {
+  /** Deliver the current value synchronously when subscribing. Defaults to true. */
+  immediate?: boolean
+}
+
+/** `time` is milliseconds on the native animation clock, shared by a notification batch. */
+export type ValueListener<T> = (value: T, time: number) => void
+
+interface Observer {
+  read(value: number): number
+  color: boolean
+  listener: ValueListener<number | Color>
+  previous: number
+}
+
+// Only sources that need a frame live here. Idle subscriptions retain no global root reference.
+const pending = new Set<ValueObservers>()
+let cancelFrame: (() => void) | undefined
+let listening = false
+let suspended = false
+
+function suspend() {
+  suspended = true
+  cancelFrame?.()
+  cancelFrame = undefined
+}
+
+function resume() {
+  suspended = false
+  schedule()
+}
+
+function schedule() {
+  if (!pending.size) {
+    cancelFrame?.()
+    cancelFrame = undefined
+    if (listening && !suspended) {
+      Application.off(Application.suspendEvent, suspend)
+      Application.off(Application.resumeEvent, resume)
+      listening = false
+    }
+    return
+  }
+  if (!listening) {
+    Application.on(Application.suspendEvent, suspend)
+    Application.on(Application.resumeEvent, resume)
+    listening = true
+  }
+  if (cancelFrame || suspended) return
+  cancelFrame = getDriver().frame(() => {
+    cancelFrame = undefined
+    const time = getDriver().now()
+    const sources = [...pending]
+    pending.clear()
+    // Capture every source before calling any listener: reentrant writes belong to the next batch.
+    const deliveries = sources.map((source) => source.snapshot(time))
+    for (const source of sources) if (source.active) pending.add(source)
+    for (const deliver of deliveries) deliver()
+    schedule()
+  })
+}
+
+function deliver(observer: Observer, value: number, time: number) {
+  try {
+    observer.listener(observer.color ? new Color(value) : value, time)
+  } catch (error) {
+    // A consumer failure must not interrupt other consumers or strand the shared frame source.
+    Trace.write(
+      `Jolt motion value subscriber failed: ${error instanceof Error ? error.stack : String(error)}`,
+      Trace.categories.Error,
+      Trace.messageType.error,
+    )
+  }
+}
+
+/** Root-owned subscriptions; mappings are evaluated only for consumers that opted in. */
+export class ValueObservers {
+  private readonly observers = new Set<Observer>()
+  private running = false
+
+  constructor(private readonly read: (time: number) => number) {}
+
+  get active() {
+    return this.running && this.observers.size > 0
+  }
+
+  subscribe(
+    read: (value: number) => number,
+    color: boolean,
+    listener: ValueListener<number | Color>,
+    options: SubscribeOptions = {},
+  ): () => void {
+    if (typeof listener !== 'function')
+      throw new TypeError('subscribe() needs a listener function.')
+    const time = getDriver().now()
+    const observer = { read, color, listener, previous: read(this.read(time)) }
+    this.observers.add(observer)
+    if (options.immediate !== false) deliver(observer, observer.previous, time)
+    if (this.active) this.changed(true)
+    return () => {
+      this.observers.delete(observer)
+      if (!this.observers.size) {
+        pending.delete(this)
+        schedule()
+      }
+    }
+  }
+
+  changed(running: boolean) {
+    this.running = running
+    if (this.observers.size) {
+      pending.add(this)
+      schedule()
+    }
+  }
+
+  snapshot(time: number): () => void {
+    const value = this.read(time)
+    const deliveries = [...this.observers].flatMap((observer) => {
+      const next = observer.read(value)
+      if (Object.is(next, observer.previous)) return []
+      observer.previous = next
+      return [{ observer, next }]
+    })
+    return () => {
+      for (const { observer, next } of deliveries)
+        if (this.observers.has(observer)) deliver(observer, next, time)
+    }
+  }
+}

package/src/value-track.ts

@@ -0,0 +1,71 @@
+import { instantTrack, type Track } from './track.js'
+
+export interface ValuePart {
+  readonly track: Track
+  readonly elapsed: number
+  readonly base: number
+  readonly span: number
+}
+
+/** Compile scalar addition before any binding's mapping. The snapshot is independent of later edits. */
+export function valueTrack(parts: readonly ValuePart[], rest: number) {
+  const value = (time: number) =>
+    parts.reduce(
+      (sum, part) =>
+        sum + part.base + part.span * part.track.valueAt(part.elapsed + time),
+      rest,
+    )
+  let finite = 0
+  const periods: number[] = []
+  for (const { track, elapsed } of parts) {
+    if (Number.isFinite(track.end)) finite = Math.max(finite, track.end - elapsed)
+    else if (elapsed < track.delay) finite = Math.max(finite, track.delay - elapsed)
+    else periods.push(Math.max(1, track.duration * (track.reverse ? 2 : 1)))
+  }
+  if (finite <= 0 && !periods.length)
+    return { track: instantTrack('x', value(0)), windowed: false }
+  const loop = finite <= 0 && periods.length ? commonPeriod(periods) : undefined
+  // Bound finite compositions too: a minutes-long base must not undersample a short pulse.
+  const duration = finite > 0 ? Math.min(finite, 4000) : (loop ?? 4000)
+  const steps = Math.max(1, Math.min(6000, Math.ceil((duration * 60) / 1000)))
+  const times = Array.from({ length: steps + 1 }, (_, i) => i / steps)
+  const values = times.map((time) => value(time * duration))
+  const endless = loop !== undefined
+  const at = (time: number) =>
+    value(
+      endless
+        ? ((time % duration) + duration) % duration
+        : Math.min(duration, Math.max(0, time)),
+    )
+  const track: Track = {
+    property: 'x',
+    delay: 0,
+    duration,
+    repeat: endless ? Infinity : 0,
+    reverse: false,
+    times,
+    values,
+    to: endless ? values[0]! : values[steps]!,
+    end: endless ? Infinity : duration,
+    arrival: endless ? Infinity : duration,
+    valueAt: at,
+    velocityAt: (time) => (at(time + 0.5) - at(time - 0.5)) * 1000,
+  }
+  return {
+    track,
+    windowed:
+      finite > duration ||
+      (!endless && parts.some(({ track }) => !Number.isFinite(track.end))),
+  }
+}
+
+function commonPeriod(periods: readonly number[]) {
+  const gcd = (a: number, b: number): number => (b ? gcd(b, a % b) : a)
+  let total = 1
+  for (const period of periods) {
+    if (!Number.isInteger(period)) return undefined
+    total = (total / gcd(total, period)) * period
+    if (total > 30000) return undefined
+  }
+  return total
+}