@number10/jsx-core 5.0.0

package/dist/animation/effect-engine.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-engine.cjs","sources":["../../src/animation/effect-engine.ts"],"sourcesContent":["/**\n * Central effect engine — runs EffectDefinitions against EffectTargets.\n *\n * The effect engine is the heart of the motion system. It interprets\n * effect definitions (pure data) and drives them against renderer-specific\n * targets using the shared tween/physics primitives.\n *\n * Renderers only implement EffectTarget — the engine handles everything else.\n */\n\nimport type { HostScheduler } from '../host-adapter'\nimport { createSpring, type SpringHandle } from './create-spring'\nimport type { EffectDefinition, EffectStep, NoiseStep } from './effect-definitions'\nimport { createTween, type TweenHandle } from './tween'\nimport type { AnimValues, EffectConfig } from './types'\n\n// ---------------------------------------------------------------------------\n// EffectTarget — what renderers implement\n// ---------------------------------------------------------------------------\n\n/**\n * Contract between the central effect engine and a renderer.\n *\n * Renderers (Pixi, Phaser) implement this to connect Core effects\n * to native nodes. The engine calls these methods to read/apply values.\n *\n * Portable components can also implement EffectTarget to use effects\n * without depending on any renderer bridge. See `applyEffect()` in\n * `@number10/jsx-core` for the 4-arg overload.\n *\n * @example\n * ```typescript\n * // Portable component effect target\n * const target: EffectTarget = {\n *   onUpdate: (values) => {\n *     if (values.x !== undefined) node.x = values.x\n *     if (values.y !== undefined) node.y = values.y\n *     if (values.alpha !== undefined) node.alpha = values.alpha\n *   },\n *   getSnapshot: () => ({\n *     x: node.x, y: node.y, alpha: node.alpha,\n *     scaleX: node.scaleX, scaleY: node.scaleY,\n *     rotation: node.rotation,\n *   }),\n *   getScheduler: () => surface.scheduler,\n *   getSize: () => ({ width: node.width, height: node.height }),\n * }\n * ```\n */\nexport interface EffectTarget {\n  /** Apply partial values to the native node */\n  onUpdate(values: Partial<AnimValues>): void\n  /** Read current values from the native node (for snapshot-based effects) */\n  getSnapshot(): AnimValues\n  /** Get the HostScheduler for frame updates */\n  getScheduler(): HostScheduler\n  /** Optional: size for origin-aware transform calculation */\n  getSize?(): { width: number; height: number }\n}\n\n// ---------------------------------------------------------------------------\n// EffectHandle\n// ---------------------------------------------------------------------------\n\n/**\n * Handle to an active effect — allows stopping and checking status.\n */\nexport interface EffectHandle {\n  /** Stop the effect immediately. onComplete is NOT called. */\n  stop(): void\n  /** Whether the effect is still running */\n  readonly isActive: boolean\n}\n\n// ---------------------------------------------------------------------------\n// Internal state management\n// ---------------------------------------------------------------------------\n\ninterface EffectState {\n  activeTweens: Set<TweenHandle<AnimValues>>\n  activeSprings: Set<SpringHandle<AnimValues>>\n  base: AnimValues\n  animatedKeys: Set<keyof AnimValues>\n  token: number\n}\n\nconst effectStates = new WeakMap<object, EffectState>()\n\nfunction getState(key: object, snapshot: AnimValues): EffectState {\n  let state = effectStates.get(key)\n  if (!state) {\n    state = {\n      activeTweens: new Set(),\n      activeSprings: new Set(),\n      base: { ...snapshot },\n      animatedKeys: new Set(),\n      token: 0,\n    }\n    effectStates.set(key, state)\n  }\n  return state\n}\n\nfunction pickAnimatedValues(\n  values: Partial<AnimValues>,\n  keys: Iterable<keyof AnimValues>\n): Partial<AnimValues> {\n  const partial: Partial<AnimValues> = {}\n  for (const key of keys) {\n    const value = values[key]\n    if (value !== undefined) {\n      partial[key] = value\n    }\n  }\n  return partial\n}\n\nfunction collectStepAnimatedKeys(step: EffectStep): Set<keyof AnimValues> {\n  if (step.type === 'noise') {\n    return new Set<keyof AnimValues>(['x', 'y'])\n  }\n\n  const keys = new Set<keyof AnimValues>()\n  for (const key of Object.keys(step.to) as (keyof AnimValues)[]) {\n    keys.add(key)\n  }\n\n  const fromValues = 'from' in step ? step.from : undefined\n  if (fromValues) {\n    for (const key of Object.keys(fromValues) as (keyof AnimValues)[]) {\n      keys.add(key)\n    }\n  }\n\n  return keys\n}\n\nfunction stopTargetEffects(state: EffectState): void {\n  for (const t of state.activeTweens) t.stop()\n  state.activeTweens.clear()\n  for (const s of state.activeSprings) s.stop()\n  state.activeSprings.clear()\n}\n\n// ---------------------------------------------------------------------------\n// runEffect\n// ---------------------------------------------------------------------------\n\n/**\n * Run an effect against a target.\n *\n * @param targetKey - Object used as WeakMap key (typically the renderer node)\n * @param target - EffectTarget implementation\n * @param definition - Effect definition (steps, loop, origin)\n * @param config - Runtime configuration (intensity, time, etc.)\n * @returns EffectHandle for stopping and status checking\n */\nexport function runEffect(\n  targetKey: object,\n  target: EffectTarget,\n  definition: EffectDefinition,\n  config: EffectConfig\n): EffectHandle {\n  const scheduler = target.getScheduler()\n\n  // Preserve original base from any existing effect — this is critical\n  // for correct \"return to original\" behavior when effects are restarted\n  // mid-animation (e.g., rapid button clicks).\n  const existingState = effectStates.get(targetKey)\n  const originalBase: AnimValues = existingState\n    ? { ...existingState.base }\n    : { ...target.getSnapshot() }\n\n  // Stop any running effect and reset target to original base\n  if (existingState) {\n    stopTargetEffects(existingState)\n    target.onUpdate(pickAnimatedValues(originalBase, existingState.animatedKeys))\n    effectStates.delete(targetKey)\n  }\n\n  // Create fresh state with the preserved original base\n  const freshState = getState(targetKey, originalBase)\n  freshState.base = { ...originalBase }\n  freshState.token++\n\n  const token = freshState.token\n  const steps: EffectStep[] =\n    typeof definition.steps === 'function'\n      ? definition.steps(freshState.base, config)\n      : definition.steps\n  const effectAnimatedKeys = new Set<keyof AnimValues>()\n  for (const step of steps) {\n    for (const key of collectStepAnimatedKeys(step)) {\n      effectAnimatedKeys.add(key)\n    }\n  }\n  freshState.animatedKeys = effectAnimatedKeys\n\n  let completed = false\n\n  const runSteps = (index: number): void => {\n    if (completed || freshState.token !== token) return\n    if (index >= steps.length) {\n      // Finite effect: reset to base values\n      if (!definition.loop) {\n        target.onUpdate(pickAnimatedValues(freshState.base, freshState.animatedKeys))\n      }\n      completed = true\n      config.onComplete?.()\n      return\n    }\n\n    const step = steps[index]\n    if (!step) {\n      runSteps(index + 1)\n      return\n    }\n    const stepAnimatedKeys = collectStepAnimatedKeys(step)\n\n    const currentSnapshot = target.getSnapshot()\n    const fromValues = 'from' in step ? step.from : undefined\n    const start = {\n      ...currentSnapshot,\n      ...(fromValues ?? {}),\n    } as AnimValues\n\n    // Apply optional \"from\" values immediately\n    if (fromValues) {\n      target.onUpdate(fromValues)\n    }\n\n    if (step.type === 'noise') {\n      runNoiseStep(freshState, token, target, scheduler, step, () => runSteps(index + 1))\n    } else if (step.type === 'tween') {\n      const handle = createTween(\n        start,\n        {\n          to: step.to,\n          duration: step.duration,\n          ease: step.ease,\n          onUpdate: (values) => {\n            if (freshState.token !== token) {\n              handle.stop()\n              return\n            }\n            target.onUpdate(pickAnimatedValues(values, stepAnimatedKeys))\n          },\n          onComplete: () => {\n            freshState.activeTweens.delete(handle)\n            if (freshState.token === token) runSteps(index + 1)\n          },\n        },\n        scheduler\n      )\n      freshState.activeTweens.add(handle)\n    } else if (step.type === 'spring') {\n      const handle = createSpring(\n        start,\n        {\n          to: step.to,\n          config: step.config,\n          onUpdate: (values) => {\n            if (freshState.token !== token) {\n              handle.stop()\n              return\n            }\n            target.onUpdate(pickAnimatedValues(values, stepAnimatedKeys))\n          },\n          onComplete: () => {\n            freshState.activeSprings.delete(handle)\n            if (freshState.token === token) runSteps(index + 1)\n          },\n        },\n        scheduler\n      )\n      freshState.activeSprings.add(handle)\n    }\n  }\n\n  // Start the first step synchronously (frame scheduling is inside createTween)\n  runSteps(0)\n\n  return {\n    stop: () => {\n      if (completed) return\n      completed = true\n      stopTargetEffects(freshState)\n      // Reset target to original base values before cleaning up,\n      // otherwise rapid re-triggers would snapshot an intermediate position.\n      target.onUpdate(pickAnimatedValues(freshState.base, freshState.animatedKeys))\n      effectStates.delete(targetKey)\n    },\n    get isActive() {\n      return !completed\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Noise step runner\n// ---------------------------------------------------------------------------\n\nfunction runNoiseStep(\n  state: EffectState,\n  token: number,\n  target: EffectTarget,\n  scheduler: HostScheduler,\n  step: NoiseStep,\n  onDone: () => void\n): void {\n  const startTime = performance.now()\n  const handle = scheduler.onFrame(() => {\n    if (state.token !== token) {\n      handle.cancel()\n      return\n    }\n    const elapsed = performance.now() - startTime\n    const progress = Math.min(elapsed / step.duration, 1)\n    const mag = step.magnitude * step.decay(progress)\n    target.onUpdate({\n      x: state.base.x + (Math.random() * 2 - 1) * mag,\n      y: state.base.y + (Math.random() * 2 - 1) * mag,\n    })\n    if (progress >= 1) {\n      handle.cancel()\n      onDone()\n    }\n  })\n}\n\n// ---------------------------------------------------------------------------\n// stopEffect\n// ---------------------------------------------------------------------------\n\n/**\n * Stop all active effects for the given target key.\n * Resets the target to its original base values.\n */\nexport function stopEffect(targetKey: object): void {\n  const state = effectStates.get(targetKey)\n  if (state) {\n    stopTargetEffects(state)\n    effectStates.delete(targetKey)\n  }\n}\n"],"names":["createTween","createSpring"],"mappings":"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"}

package/dist/animation/effect-engine.d.ts

@@ -0,0 +1,70 @@
+import { HostScheduler } from '../host-adapter';
+import { EffectDefinition } from './effect-definitions';
+import { AnimValues, EffectConfig } from './types';
+/**
+ * Contract between the central effect engine and a renderer.
+ *
+ * Renderers (Pixi, Phaser) implement this to connect Core effects
+ * to native nodes. The engine calls these methods to read/apply values.
+ *
+ * Portable components can also implement EffectTarget to use effects
+ * without depending on any renderer bridge. See `applyEffect()` in
+ * `@number10/jsx-core` for the 4-arg overload.
+ *
+ * @example
+ * ```typescript
+ * // Portable component effect target
+ * const target: EffectTarget = {
+ *   onUpdate: (values) => {
+ *     if (values.x !== undefined) node.x = values.x
+ *     if (values.y !== undefined) node.y = values.y
+ *     if (values.alpha !== undefined) node.alpha = values.alpha
+ *   },
+ *   getSnapshot: () => ({
+ *     x: node.x, y: node.y, alpha: node.alpha,
+ *     scaleX: node.scaleX, scaleY: node.scaleY,
+ *     rotation: node.rotation,
+ *   }),
+ *   getScheduler: () => surface.scheduler,
+ *   getSize: () => ({ width: node.width, height: node.height }),
+ * }
+ * ```
+ */
+export interface EffectTarget {
+    /** Apply partial values to the native node */
+    onUpdate(values: Partial<AnimValues>): void;
+    /** Read current values from the native node (for snapshot-based effects) */
+    getSnapshot(): AnimValues;
+    /** Get the HostScheduler for frame updates */
+    getScheduler(): HostScheduler;
+    /** Optional: size for origin-aware transform calculation */
+    getSize?(): {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Handle to an active effect — allows stopping and checking status.
+ */
+export interface EffectHandle {
+    /** Stop the effect immediately. onComplete is NOT called. */
+    stop(): void;
+    /** Whether the effect is still running */
+    readonly isActive: boolean;
+}
+/**
+ * Run an effect against a target.
+ *
+ * @param targetKey - Object used as WeakMap key (typically the renderer node)
+ * @param target - EffectTarget implementation
+ * @param definition - Effect definition (steps, loop, origin)
+ * @param config - Runtime configuration (intensity, time, etc.)
+ * @returns EffectHandle for stopping and status checking
+ */
+export declare function runEffect(targetKey: object, target: EffectTarget, definition: EffectDefinition, config: EffectConfig): EffectHandle;
+/**
+ * Stop all active effects for the given target key.
+ * Resets the target to its original base values.
+ */
+export declare function stopEffect(targetKey: object): void;
+//# sourceMappingURL=effect-engine.d.ts.map

package/dist/animation/effect-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-engine.d.ts","sourceRoot":"","sources":["../../src/animation/effect-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,sBAAsB,CAAA;AAEnF,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAMvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,YAAY;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAA;IAC3C,4EAA4E;IAC5E,WAAW,IAAI,UAAU,CAAA;IACzB,8CAA8C;IAC9C,YAAY,IAAI,aAAa,CAAA;IAC7B,4DAA4D;IAC5D,OAAO,CAAC,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9C;AAMD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,IAAI,IAAI,IAAI,CAAA;IACZ,0CAA0C;IAC1C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAC3B;AA4ED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,YAAY,GACnB,YAAY,CAsId;AAsCD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAMlD"}

package/dist/animation/effect-engine.js

@@ -0,0 +1,189 @@
+import { createSpring } from "./create-spring.js";
+import { createTween } from "./tween.js";
+const effectStates = /* @__PURE__ */ new WeakMap();
+function getState(key, snapshot) {
+  let state = effectStates.get(key);
+  if (!state) {
+    state = {
+      activeTweens: /* @__PURE__ */ new Set(),
+      activeSprings: /* @__PURE__ */ new Set(),
+      base: { ...snapshot },
+      animatedKeys: /* @__PURE__ */ new Set(),
+      token: 0
+    };
+    effectStates.set(key, state);
+  }
+  return state;
+}
+function pickAnimatedValues(values, keys) {
+  const partial = {};
+  for (const key of keys) {
+    const value = values[key];
+    if (value !== void 0) {
+      partial[key] = value;
+    }
+  }
+  return partial;
+}
+function collectStepAnimatedKeys(step) {
+  if (step.type === "noise") {
+    return /* @__PURE__ */ new Set(["x", "y"]);
+  }
+  const keys = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(step.to)) {
+    keys.add(key);
+  }
+  const fromValues = "from" in step ? step.from : void 0;
+  if (fromValues) {
+    for (const key of Object.keys(fromValues)) {
+      keys.add(key);
+    }
+  }
+  return keys;
+}
+function stopTargetEffects(state) {
+  for (const t of state.activeTweens) t.stop();
+  state.activeTweens.clear();
+  for (const s of state.activeSprings) s.stop();
+  state.activeSprings.clear();
+}
+function runEffect(targetKey, target, definition, config) {
+  const scheduler = target.getScheduler();
+  const existingState = effectStates.get(targetKey);
+  const originalBase = existingState ? { ...existingState.base } : { ...target.getSnapshot() };
+  if (existingState) {
+    stopTargetEffects(existingState);
+    target.onUpdate(pickAnimatedValues(originalBase, existingState.animatedKeys));
+    effectStates.delete(targetKey);
+  }
+  const freshState = getState(targetKey, originalBase);
+  freshState.base = { ...originalBase };
+  freshState.token++;
+  const token = freshState.token;
+  const steps = typeof definition.steps === "function" ? definition.steps(freshState.base, config) : definition.steps;
+  const effectAnimatedKeys = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    for (const key of collectStepAnimatedKeys(step)) {
+      effectAnimatedKeys.add(key);
+    }
+  }
+  freshState.animatedKeys = effectAnimatedKeys;
+  let completed = false;
+  const runSteps = (index) => {
+    if (completed || freshState.token !== token) return;
+    if (index >= steps.length) {
+      if (!definition.loop) {
+        target.onUpdate(pickAnimatedValues(freshState.base, freshState.animatedKeys));
+      }
+      completed = true;
+      config.onComplete?.();
+      return;
+    }
+    const step = steps[index];
+    if (!step) {
+      runSteps(index + 1);
+      return;
+    }
+    const stepAnimatedKeys = collectStepAnimatedKeys(step);
+    const currentSnapshot = target.getSnapshot();
+    const fromValues = "from" in step ? step.from : void 0;
+    const start = {
+      ...currentSnapshot,
+      ...fromValues ?? {}
+    };
+    if (fromValues) {
+      target.onUpdate(fromValues);
+    }
+    if (step.type === "noise") {
+      runNoiseStep(freshState, token, target, scheduler, step, () => runSteps(index + 1));
+    } else if (step.type === "tween") {
+      const handle = createTween(
+        start,
+        {
+          to: step.to,
+          duration: step.duration,
+          ease: step.ease,
+          onUpdate: (values) => {
+            if (freshState.token !== token) {
+              handle.stop();
+              return;
+            }
+            target.onUpdate(pickAnimatedValues(values, stepAnimatedKeys));
+          },
+          onComplete: () => {
+            freshState.activeTweens.delete(handle);
+            if (freshState.token === token) runSteps(index + 1);
+          }
+        },
+        scheduler
+      );
+      freshState.activeTweens.add(handle);
+    } else if (step.type === "spring") {
+      const handle = createSpring(
+        start,
+        {
+          to: step.to,
+          config: step.config,
+          onUpdate: (values) => {
+            if (freshState.token !== token) {
+              handle.stop();
+              return;
+            }
+            target.onUpdate(pickAnimatedValues(values, stepAnimatedKeys));
+          },
+          onComplete: () => {
+            freshState.activeSprings.delete(handle);
+            if (freshState.token === token) runSteps(index + 1);
+          }
+        },
+        scheduler
+      );
+      freshState.activeSprings.add(handle);
+    }
+  };
+  runSteps(0);
+  return {
+    stop: () => {
+      if (completed) return;
+      completed = true;
+      stopTargetEffects(freshState);
+      target.onUpdate(pickAnimatedValues(freshState.base, freshState.animatedKeys));
+      effectStates.delete(targetKey);
+    },
+    get isActive() {
+      return !completed;
+    }
+  };
+}
+function runNoiseStep(state, token, target, scheduler, step, onDone) {
+  const startTime = performance.now();
+  const handle = scheduler.onFrame(() => {
+    if (state.token !== token) {
+      handle.cancel();
+      return;
+    }
+    const elapsed = performance.now() - startTime;
+    const progress = Math.min(elapsed / step.duration, 1);
+    const mag = step.magnitude * step.decay(progress);
+    target.onUpdate({
+      x: state.base.x + (Math.random() * 2 - 1) * mag,
+      y: state.base.y + (Math.random() * 2 - 1) * mag
+    });
+    if (progress >= 1) {
+      handle.cancel();
+      onDone();
+    }
+  });
+}
+function stopEffect(targetKey) {
+  const state = effectStates.get(targetKey);
+  if (state) {
+    stopTargetEffects(state);
+    effectStates.delete(targetKey);
+  }
+}
+export {
+  runEffect,
+  stopEffect
+};
+//# sourceMappingURL=effect-engine.js.map

package/dist/animation/effect-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-engine.js","sources":["../../src/animation/effect-engine.ts"],"sourcesContent":["/**\n * Central effect engine — runs EffectDefinitions against EffectTargets.\n *\n * The effect engine is the heart of the motion system. It interprets\n * effect definitions (pure data) and drives them against renderer-specific\n * targets using the shared tween/physics primitives.\n *\n * Renderers only implement EffectTarget — the engine handles everything else.\n */\n\nimport type { HostScheduler } from '../host-adapter'\nimport { createSpring, type SpringHandle } from './create-spring'\nimport type { EffectDefinition, EffectStep, NoiseStep } from './effect-definitions'\nimport { createTween, type TweenHandle } from './tween'\nimport type { AnimValues, EffectConfig } from './types'\n\n// ---------------------------------------------------------------------------\n// EffectTarget — what renderers implement\n// ---------------------------------------------------------------------------\n\n/**\n * Contract between the central effect engine and a renderer.\n *\n * Renderers (Pixi, Phaser) implement this to connect Core effects\n * to native nodes. The engine calls these methods to read/apply values.\n *\n * Portable components can also implement EffectTarget to use effects\n * without depending on any renderer bridge. See `applyEffect()` in\n * `@number10/jsx-core` for the 4-arg overload.\n *\n * @example\n * ```typescript\n * // Portable component effect target\n * const target: EffectTarget = {\n *   onUpdate: (values) => {\n *     if (values.x !== undefined) node.x = values.x\n *     if (values.y !== undefined) node.y = values.y\n *     if (values.alpha !== undefined) node.alpha = values.alpha\n *   },\n *   getSnapshot: () => ({\n *     x: node.x, y: node.y, alpha: node.alpha,\n *     scaleX: node.scaleX, scaleY: node.scaleY,\n *     rotation: node.rotation,\n *   }),\n *   getScheduler: () => surface.scheduler,\n *   getSize: () => ({ width: node.width, height: node.height }),\n * }\n * ```\n */\nexport interface EffectTarget {\n  /** Apply partial values to the native node */\n  onUpdate(values: Partial<AnimValues>): void\n  /** Read current values from the native node (for snapshot-based effects) */\n  getSnapshot(): AnimValues\n  /** Get the HostScheduler for frame updates */\n  getScheduler(): HostScheduler\n  /** Optional: size for origin-aware transform calculation */\n  getSize?(): { width: number; height: number }\n}\n\n// ---------------------------------------------------------------------------\n// EffectHandle\n// ---------------------------------------------------------------------------\n\n/**\n * Handle to an active effect — allows stopping and checking status.\n */\nexport interface EffectHandle {\n  /** Stop the effect immediately. onComplete is NOT called. */\n  stop(): void\n  /** Whether the effect is still running */\n  readonly isActive: boolean\n}\n\n// ---------------------------------------------------------------------------\n// Internal state management\n// ---------------------------------------------------------------------------\n\ninterface EffectState {\n  activeTweens: Set<TweenHandle<AnimValues>>\n  activeSprings: Set<SpringHandle<AnimValues>>\n  base: AnimValues\n  animatedKeys: Set<keyof AnimValues>\n  token: number\n}\n\nconst effectStates = new WeakMap<object, EffectState>()\n\nfunction getState(key: object, snapshot: AnimValues): EffectState {\n  let state = effectStates.get(key)\n  if (!state) {\n    state = {\n      activeTweens: new Set(),\n      activeSprings: new Set(),\n      base: { ...snapshot },\n      animatedKeys: new Set(),\n      token: 0,\n    }\n    effectStates.set(key, state)\n  }\n  return state\n}\n\nfunction pickAnimatedValues(\n  values: Partial<AnimValues>,\n  keys: Iterable<keyof AnimValues>\n): Partial<AnimValues> {\n  const partial: Partial<AnimValues> = {}\n  for (const key of keys) {\n    const value = values[key]\n    if (value !== undefined) {\n      partial[key] = value\n    }\n  }\n  return partial\n}\n\nfunction collectStepAnimatedKeys(step: EffectStep): Set<keyof AnimValues> {\n  if (step.type === 'noise') {\n    return new Set<keyof AnimValues>(['x', 'y'])\n  }\n\n  const keys = new Set<keyof AnimValues>()\n  for (const key of Object.keys(step.to) as (keyof AnimValues)[]) {\n    keys.add(key)\n  }\n\n  const fromValues = 'from' in step ? step.from : undefined\n  if (fromValues) {\n    for (const key of Object.keys(fromValues) as (keyof AnimValues)[]) {\n      keys.add(key)\n    }\n  }\n\n  return keys\n}\n\nfunction stopTargetEffects(state: EffectState): void {\n  for (const t of state.activeTweens) t.stop()\n  state.activeTweens.clear()\n  for (const s of state.activeSprings) s.stop()\n  state.activeSprings.clear()\n}\n\n// ---------------------------------------------------------------------------\n// runEffect\n// ---------------------------------------------------------------------------\n\n/**\n * Run an effect against a target.\n *\n * @param targetKey - Object used as WeakMap key (typically the renderer node)\n * @param target - EffectTarget implementation\n * @param definition - Effect definition (steps, loop, origin)\n * @param config - Runtime configuration (intensity, time, etc.)\n * @returns EffectHandle for stopping and status checking\n */\nexport function runEffect(\n  targetKey: object,\n  target: EffectTarget,\n  definition: EffectDefinition,\n  config: EffectConfig\n): EffectHandle {\n  const scheduler = target.getScheduler()\n\n  // Preserve original base from any existing effect — this is critical\n  // for correct \"return to original\" behavior when effects are restarted\n  // mid-animation (e.g., rapid button clicks).\n  const existingState = effectStates.get(targetKey)\n  const originalBase: AnimValues = existingState\n    ? { ...existingState.base }\n    : { ...target.getSnapshot() }\n\n  // Stop any running effect and reset target to original base\n  if (existingState) {\n    stopTargetEffects(existingState)\n    target.onUpdate(pickAnimatedValues(originalBase, existingState.animatedKeys))\n    effectStates.delete(targetKey)\n  }\n\n  // Create fresh state with the preserved original base\n  const freshState = getState(targetKey, originalBase)\n  freshState.base = { ...originalBase }\n  freshState.token++\n\n  const token = freshState.token\n  const steps: EffectStep[] =\n    typeof definition.steps === 'function'\n      ? definition.steps(freshState.base, config)\n      : definition.steps\n  const effectAnimatedKeys = new Set<keyof AnimValues>()\n  for (const step of steps) {\n    for (const key of collectStepAnimatedKeys(step)) {\n      effectAnimatedKeys.add(key)\n    }\n  }\n  freshState.animatedKeys = effectAnimatedKeys\n\n  let completed = false\n\n  const runSteps = (index: number): void => {\n    if (completed || freshState.token !== token) return\n    if (index >= steps.length) {\n      // Finite effect: reset to base values\n      if (!definition.loop) {\n        target.onUpdate(pickAnimatedValues(freshState.base, freshState.animatedKeys))\n      }\n      completed = true\n      config.onComplete?.()\n      return\n    }\n\n    const step = steps[index]\n    if (!step) {\n      runSteps(index + 1)\n      return\n    }\n    const stepAnimatedKeys = collectStepAnimatedKeys(step)\n\n    const currentSnapshot = target.getSnapshot()\n    const fromValues = 'from' in step ? step.from : undefined\n    const start = {\n      ...currentSnapshot,\n      ...(fromValues ?? {}),\n    } as AnimValues\n\n    // Apply optional \"from\" values immediately\n    if (fromValues) {\n      target.onUpdate(fromValues)\n    }\n\n    if (step.type === 'noise') {\n      runNoiseStep(freshState, token, target, scheduler, step, () => runSteps(index + 1))\n    } else if (step.type === 'tween') {\n      const handle = createTween(\n        start,\n        {\n          to: step.to,\n          duration: step.duration,\n          ease: step.ease,\n          onUpdate: (values) => {\n            if (freshState.token !== token) {\n              handle.stop()\n              return\n            }\n            target.onUpdate(pickAnimatedValues(values, stepAnimatedKeys))\n          },\n          onComplete: () => {\n            freshState.activeTweens.delete(handle)\n            if (freshState.token === token) runSteps(index + 1)\n          },\n        },\n        scheduler\n      )\n      freshState.activeTweens.add(handle)\n    } else if (step.type === 'spring') {\n      const handle = createSpring(\n        start,\n        {\n          to: step.to,\n          config: step.config,\n          onUpdate: (values) => {\n            if (freshState.token !== token) {\n              handle.stop()\n              return\n            }\n            target.onUpdate(pickAnimatedValues(values, stepAnimatedKeys))\n          },\n          onComplete: () => {\n            freshState.activeSprings.delete(handle)\n            if (freshState.token === token) runSteps(index + 1)\n          },\n        },\n        scheduler\n      )\n      freshState.activeSprings.add(handle)\n    }\n  }\n\n  // Start the first step synchronously (frame scheduling is inside createTween)\n  runSteps(0)\n\n  return {\n    stop: () => {\n      if (completed) return\n      completed = true\n      stopTargetEffects(freshState)\n      // Reset target to original base values before cleaning up,\n      // otherwise rapid re-triggers would snapshot an intermediate position.\n      target.onUpdate(pickAnimatedValues(freshState.base, freshState.animatedKeys))\n      effectStates.delete(targetKey)\n    },\n    get isActive() {\n      return !completed\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Noise step runner\n// ---------------------------------------------------------------------------\n\nfunction runNoiseStep(\n  state: EffectState,\n  token: number,\n  target: EffectTarget,\n  scheduler: HostScheduler,\n  step: NoiseStep,\n  onDone: () => void\n): void {\n  const startTime = performance.now()\n  const handle = scheduler.onFrame(() => {\n    if (state.token !== token) {\n      handle.cancel()\n      return\n    }\n    const elapsed = performance.now() - startTime\n    const progress = Math.min(elapsed / step.duration, 1)\n    const mag = step.magnitude * step.decay(progress)\n    target.onUpdate({\n      x: state.base.x + (Math.random() * 2 - 1) * mag,\n      y: state.base.y + (Math.random() * 2 - 1) * mag,\n    })\n    if (progress >= 1) {\n      handle.cancel()\n      onDone()\n    }\n  })\n}\n\n// ---------------------------------------------------------------------------\n// stopEffect\n// ---------------------------------------------------------------------------\n\n/**\n * Stop all active effects for the given target key.\n * Resets the target to its original base values.\n */\nexport function stopEffect(targetKey: object): void {\n  const state = effectStates.get(targetKey)\n  if (state) {\n    stopTargetEffects(state)\n    effectStates.delete(targetKey)\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/animation/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Animation utilities — @number10/jsx-core
+ *
+ * Three complementary animation approaches:
+ * - createTween / useTween: time-based duration+easing interpolation
+ * - createSpring / useSpring: physics-based spring animation via signals
+ *
+ * Effect system (migration target):
+ * - types: AnimValues, EffectConfig
+ * - easing: Complete Penner equations
+ * - effect-definitions: 23 built-in effects as pure data
+ * - effect-engine: Central effect runner with EffectTarget contract
+ */
+export * from './animated-signal';
+export { createSpring, type SpringAnimationConfig, type SpringHandle } from './create-spring';
+export { Easing, type EasingFn } from './easing';
+export { EFFECT_DEFINITIONS, resolveEffectTransformOrigin, type EffectDefinition, type EffectStep, type EffectTransformOrigin, type NoiseStep, type SpringStep, type TweenStep, } from './effect-definitions';
+export { runEffect, stopEffect, type EffectHandle, type EffectTarget } from './effect-engine';
+export * from './spring-physics';
+export * from './tween';
+export type { AnimValues, EffectConfig } from './types';
+export * from './useSpring';
+export { TWEEN_PRESETS, useTween, useTweens, type TweenAnimationStep, type TweenConfig, type TweenPreset, } from './useTween';
+//# sourceMappingURL=index.d.ts.map

package/dist/animation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/animation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,YAAY,EAAE,KAAK,qBAAqB,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC7F,OAAO,EAAE,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC5B,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,SAAS,GACf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC7F,cAAc,kBAAkB,CAAA;AAChC,cAAc,SAAS,CAAA;AACvB,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,OAAO,EACL,aAAa,EACb,QAAQ,EACR,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,WAAW,GACjB,MAAM,YAAY,CAAA"}

package/dist/animation/spring-physics.cjs

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_SPRING_CONFIG = {
+  tension: 170,
+  friction: 26,
+  mass: 1,
+  restVelocity: 0.01,
+  restDelta: 0.01,
+  clamp: false
+};
+const SPRING_PRESETS = {
+  /** Gentle, but still responsive animation */
+  gentle: { tension: 350, friction: 24, restVelocity: 0.5, restDelta: 0.1 },
+  /** Moderate, balanced animation (default) */
+  default: { tension: 600, friction: 40, restVelocity: 0.5, restDelta: 0.1 },
+  /** Bouncy, playful animation tuned for quick UI feedback */
+  wobbly: { tension: 900, friction: 35, restVelocity: 0.5, restDelta: 0.1 },
+  /** Very fast, snappy response for press/pulse-style interactions */
+  stiff: { tension: 1800, friction: 60, restVelocity: 0.5, restDelta: 0.1 },
+  /** Slow, deliberate animation */
+  slow: { tension: 350, friction: 48, restVelocity: 0.5, restDelta: 0.1 },
+  /** Nearly instant transition */
+  instant: { tension: 2500, friction: 90, restVelocity: 1, restDelta: 0.02, clamp: true }
+};
+class SpringPhysics {
+  config;
+  /**
+   * Creates a new spring physics engine
+   * @param config - Spring configuration
+   */
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_SPRING_CONFIG, ...config };
+  }
+  /**
+   * Updates spring configuration
+   * @param config - Partial config to merge with current
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Performs one physics step
+   * Uses semi-implicit Euler integration for stability
+   * @param state - Current spring state
+   * @param target - Target value
+   * @param deltaTime - Time delta in seconds
+   * @returns New spring state
+   */
+  step(state, target, deltaTime) {
+    const { tension, friction, mass, clamp } = this.config;
+    const springForce = -tension * (state.value - target);
+    const dampingForce = -friction * state.velocity;
+    const acceleration = (springForce + dampingForce) / mass;
+    const newVelocity = state.velocity + acceleration * deltaTime;
+    let newValue = state.value + newVelocity * deltaTime;
+    if (clamp) {
+      const min = Math.min(state.value, target);
+      const max = Math.max(state.value, target);
+      newValue = Math.max(min, Math.min(max, newValue));
+    }
+    return {
+      value: newValue,
+      velocity: newVelocity
+    };
+  }
+  /**
+   * Checks if spring has reached rest state
+   * @param state - Current spring state
+   * @param target - Target value
+   * @returns True if spring is at rest
+   */
+  isAtRest(state, target) {
+    const { restVelocity, restDelta } = this.config;
+    const isVelocitySmall = Math.abs(state.velocity) <= restVelocity;
+    const isDisplacementSmall = Math.abs(state.value - target) <= restDelta;
+    return isVelocitySmall && isDisplacementSmall;
+  }
+  /**
+   * Snaps spring to target if at rest
+   * @param state - Current spring state
+   * @param target - Target value
+   * @returns Adjusted state (snapped if at rest)
+   */
+  snapIfAtRest(state, target) {
+    if (this.isAtRest(state, target)) {
+      return { value: target, velocity: 0 };
+    }
+    return state;
+  }
+}
+exports.DEFAULT_SPRING_CONFIG = DEFAULT_SPRING_CONFIG;
+exports.SPRING_PRESETS = SPRING_PRESETS;
+exports.SpringPhysics = SpringPhysics;
+//# sourceMappingURL=spring-physics.cjs.map

package/dist/animation/spring-physics.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-physics.cjs","sources":["../../src/animation/spring-physics.ts"],"sourcesContent":["/**\n * Spring physics engine for smooth, natural animations\n * Based on spring-damper system with configurable tension, friction, and mass\n *\n * @migration(audit:surface-access) Phase 7 — moved to @number10/jsx-core ✅\n */\n\n/**\n * Configuration for spring physics behavior\n */\nexport interface SpringConfig {\n  /** Spring stiffness (higher = faster, snappier). Default: 170 */\n  tension?: number\n  /** Damping force (higher = less oscillation). Default: 26 */\n  friction?: number\n  /** Mass of the animated object (higher = slower). Default: 1 */\n  mass?: number\n  /** Velocity threshold below which animation stops. Default: 0.01 */\n  restVelocity?: number\n  /** Distance threshold below which animation stops. Default: 0.01 */\n  restDelta?: number\n  /** Clamp values to prevent overshoot. Default: false */\n  clamp?: boolean\n  /**\n   * Called once when the spring starts moving from rest.\n   * Fires BEFORE the first physics step.\n   */\n  onStart?: (() => void) | undefined\n  /**\n   * Called on every frame with the current spring value.\n   * Useful for syncing non-signal state.\n   */\n  onUpdate?: ((value: number) => void) | undefined\n}\n\n/**\n * Spring physics state\n */\nexport interface SpringState {\n  /** Current value */\n  value: number\n  /** Current velocity */\n  velocity: number\n}\n\n/**\n * Default spring configuration (similar to react-spring)\n */\nexport const DEFAULT_SPRING_CONFIG: Required<Omit<SpringConfig, 'onStart' | 'onUpdate'>> = {\n  tension: 170,\n  friction: 26,\n  mass: 1,\n  restVelocity: 0.01,\n  restDelta: 0.01,\n  clamp: false,\n}\n\n/**\n * Preset spring configurations for common use cases\n * Note: clamp prevents overshoot but can make animations feel less natural\n * For UI animations, consider enabling clamp to prevent visual artifacts\n */\nexport const SPRING_PRESETS = {\n  /** Gentle, but still responsive animation */\n  gentle: { tension: 350, friction: 24, restVelocity: 0.5, restDelta: 0.1 },\n  /** Moderate, balanced animation (default) */\n  default: { tension: 600, friction: 40, restVelocity: 0.5, restDelta: 0.1 },\n  /** Bouncy, playful animation tuned for quick UI feedback */\n  wobbly: { tension: 900, friction: 35, restVelocity: 0.5, restDelta: 0.1 },\n  /** Very fast, snappy response for press/pulse-style interactions */\n  stiff: { tension: 1800, friction: 60, restVelocity: 0.5, restDelta: 0.1 },\n  /** Slow, deliberate animation */\n  slow: { tension: 350, friction: 48, restVelocity: 0.5, restDelta: 0.1 },\n  /** Nearly instant transition */\n  instant: { tension: 2500, friction: 90, restVelocity: 1, restDelta: 0.02, clamp: true },\n} as const\n\n/**\n * Type for animation preset keys\n */\nexport type AnimationPreset = keyof typeof SPRING_PRESETS\n/**\n * Type for animation configuration (preset name or custom config)\n */\nexport type AnimationConfig = AnimationPreset | SpringConfig\n\n/**\n * Spring physics engine\n * Implements spring-damper physics for smooth, natural animations\n */\nexport class SpringPhysics {\n  private config: Required<Omit<SpringConfig, 'onStart' | 'onUpdate'>> &\n    Pick<SpringConfig, 'onStart' | 'onUpdate'>\n\n  /**\n   * Creates a new spring physics engine\n   * @param config - Spring configuration\n   */\n  constructor(config: SpringConfig = {}) {\n    this.config = { ...DEFAULT_SPRING_CONFIG, ...config } as typeof this.config\n  }\n\n  /**\n   * Updates spring configuration\n   * @param config - Partial config to merge with current\n   */\n  updateConfig(config: Partial<SpringConfig>): void {\n    this.config = { ...this.config, ...config } as typeof this.config\n  }\n\n  /**\n   * Performs one physics step\n   * Uses semi-implicit Euler integration for stability\n   * @param state - Current spring state\n   * @param target - Target value\n   * @param deltaTime - Time delta in seconds\n   * @returns New spring state\n   */\n  step(state: SpringState, target: number, deltaTime: number): SpringState {\n    const { tension, friction, mass, clamp } = this.config\n\n    // Calculate spring force (Hooke's law)\n    const springForce = -tension * (state.value - target)\n\n    // Calculate damping force\n    const dampingForce = -friction * state.velocity\n\n    // Calculate acceleration (F = ma → a = F/m)\n    const acceleration = (springForce + dampingForce) / mass\n\n    // Update velocity (semi-implicit Euler)\n    const newVelocity = state.velocity + acceleration * deltaTime\n\n    // Update position\n    let newValue = state.value + newVelocity * deltaTime\n\n    // Clamp if enabled\n    if (clamp) {\n      const min = Math.min(state.value, target)\n      const max = Math.max(state.value, target)\n      newValue = Math.max(min, Math.min(max, newValue))\n    }\n\n    return {\n      value: newValue,\n      velocity: newVelocity,\n    }\n  }\n\n  /**\n   * Checks if spring has reached rest state\n   * @param state - Current spring state\n   * @param target - Target value\n   * @returns True if spring is at rest\n   */\n  isAtRest(state: SpringState, target: number): boolean {\n    const { restVelocity, restDelta } = this.config\n    const isVelocitySmall = Math.abs(state.velocity) <= restVelocity\n    const isDisplacementSmall = Math.abs(state.value - target) <= restDelta\n    return isVelocitySmall && isDisplacementSmall\n  }\n\n  /**\n   * Snaps spring to target if at rest\n   * @param state - Current spring state\n   * @param target - Target value\n   * @returns Adjusted state (snapped if at rest)\n   */\n  snapIfAtRest(state: SpringState, target: number): SpringState {\n    if (this.isAtRest(state, target)) {\n      return { value: target, velocity: 0 }\n    }\n    return state\n  }\n}\n"],"names":[],"mappings":";;AAgDO,MAAM,wBAA8E;AAAA,EACzF,SAAS;AAAA,EACT,UAAU;AAAA,EACV,MAAM;AAAA,EACN,cAAc;AAAA,EACd,WAAW;AAAA,EACX,OAAO;AACT;AAOO,MAAM,iBAAiB;AAAA;AAAA,EAE5B,QAAQ,EAAE,SAAS,KAAK,UAAU,IAAI,cAAc,KAAK,WAAW,IAAA;AAAA;AAAA,EAEpE,SAAS,EAAE,SAAS,KAAK,UAAU,IAAI,cAAc,KAAK,WAAW,IAAA;AAAA;AAAA,EAErE,QAAQ,EAAE,SAAS,KAAK,UAAU,IAAI,cAAc,KAAK,WAAW,IAAA;AAAA;AAAA,EAEpE,OAAO,EAAE,SAAS,MAAM,UAAU,IAAI,cAAc,KAAK,WAAW,IAAA;AAAA;AAAA,EAEpE,MAAM,EAAE,SAAS,KAAK,UAAU,IAAI,cAAc,KAAK,WAAW,IAAA;AAAA;AAAA,EAElE,SAAS,EAAE,SAAS,MAAM,UAAU,IAAI,cAAc,GAAG,WAAW,MAAM,OAAO,KAAA;AACnF;AAeO,MAAM,cAAc;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA,EAOR,YAAY,SAAuB,IAAI;AACrC,SAAK,SAAS,EAAE,GAAG,uBAAuB,GAAG,OAAA;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAa,QAAqC;AAChD,SAAK,SAAS,EAAE,GAAG,KAAK,QAAQ,GAAG,OAAA;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,KAAK,OAAoB,QAAgB,WAAgC;AACvE,UAAM,EAAE,SAAS,UAAU,MAAM,MAAA,IAAU,KAAK;AAGhD,UAAM,cAAc,CAAC,WAAW,MAAM,QAAQ;AAG9C,UAAM,eAAe,CAAC,WAAW,MAAM;AAGvC,UAAM,gBAAgB,cAAc,gBAAgB;AAGpD,UAAM,cAAc,MAAM,WAAW,eAAe;AAGpD,QAAI,WAAW,MAAM,QAAQ,cAAc;AAG3C,QAAI,OAAO;AACT,YAAM,MAAM,KAAK,IAAI,MAAM,OAAO,MAAM;AACxC,YAAM,MAAM,KAAK,IAAI,MAAM,OAAO,MAAM;AACxC,iBAAW,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,QAAQ,CAAC;AAAA,IAClD;AAEA,WAAO;AAAA,MACL,OAAO;AAAA,MACP,UAAU;AAAA,IAAA;AAAA,EAEd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,SAAS,OAAoB,QAAyB;AACpD,UAAM,EAAE,cAAc,UAAA,IAAc,KAAK;AACzC,UAAM,kBAAkB,KAAK,IAAI,MAAM,QAAQ,KAAK;AACpD,UAAM,sBAAsB,KAAK,IAAI,MAAM,QAAQ,MAAM,KAAK;AAC9D,WAAO,mBAAmB;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,aAAa,OAAoB,QAA6B;AAC5D,QAAI,KAAK,SAAS,OAAO,MAAM,GAAG;AAChC,aAAO,EAAE,OAAO,QAAQ,UAAU,EAAA;AAAA,IACpC;AACA,WAAO;AAAA,EACT;AACF;;;;"}

package/dist/animation/spring-physics.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Spring physics engine for smooth, natural animations
+ * Based on spring-damper system with configurable tension, friction, and mass
+ *
+ * @migration(audit:surface-access) Phase 7 — moved to @number10/jsx-core ✅
+ */
+/**
+ * Configuration for spring physics behavior
+ */
+export interface SpringConfig {
+    /** Spring stiffness (higher = faster, snappier). Default: 170 */
+    tension?: number;
+    /** Damping force (higher = less oscillation). Default: 26 */
+    friction?: number;
+    /** Mass of the animated object (higher = slower). Default: 1 */
+    mass?: number;
+    /** Velocity threshold below which animation stops. Default: 0.01 */
+    restVelocity?: number;
+    /** Distance threshold below which animation stops. Default: 0.01 */
+    restDelta?: number;
+    /** Clamp values to prevent overshoot. Default: false */
+    clamp?: boolean;
+    /**
+     * Called once when the spring starts moving from rest.
+     * Fires BEFORE the first physics step.
+     */
+    onStart?: (() => void) | undefined;
+    /**
+     * Called on every frame with the current spring value.
+     * Useful for syncing non-signal state.
+     */
+    onUpdate?: ((value: number) => void) | undefined;
+}
+/**
+ * Spring physics state
+ */
+export interface SpringState {
+    /** Current value */
+    value: number;
+    /** Current velocity */
+    velocity: number;
+}
+/**
+ * Default spring configuration (similar to react-spring)
+ */
+export declare const DEFAULT_SPRING_CONFIG: Required<Omit<SpringConfig, 'onStart' | 'onUpdate'>>;
+/**
+ * Preset spring configurations for common use cases
+ * Note: clamp prevents overshoot but can make animations feel less natural
+ * For UI animations, consider enabling clamp to prevent visual artifacts
+ */
+export declare const SPRING_PRESETS: {
+    /** Gentle, but still responsive animation */
+    readonly gentle: {
+        readonly tension: 350;
+        readonly friction: 24;
+        readonly restVelocity: 0.5;
+        readonly restDelta: 0.1;
+    };
+    /** Moderate, balanced animation (default) */
+    readonly default: {
+        readonly tension: 600;
+        readonly friction: 40;
+        readonly restVelocity: 0.5;
+        readonly restDelta: 0.1;
+    };
+    /** Bouncy, playful animation tuned for quick UI feedback */
+    readonly wobbly: {
+        readonly tension: 900;
+        readonly friction: 35;
+        readonly restVelocity: 0.5;
+        readonly restDelta: 0.1;
+    };
+    /** Very fast, snappy response for press/pulse-style interactions */
+    readonly stiff: {
+        readonly tension: 1800;
+        readonly friction: 60;
+        readonly restVelocity: 0.5;
+        readonly restDelta: 0.1;
+    };
+    /** Slow, deliberate animation */
+    readonly slow: {
+        readonly tension: 350;
+        readonly friction: 48;
+        readonly restVelocity: 0.5;
+        readonly restDelta: 0.1;
+    };
+    /** Nearly instant transition */
+    readonly instant: {
+        readonly tension: 2500;
+        readonly friction: 90;
+        readonly restVelocity: 1;
+        readonly restDelta: 0.02;
+        readonly clamp: true;
+    };
+};
+/**
+ * Type for animation preset keys
+ */
+export type AnimationPreset = keyof typeof SPRING_PRESETS;
+/**
+ * Type for animation configuration (preset name or custom config)
+ */
+export type AnimationConfig = AnimationPreset | SpringConfig;
+/**
+ * Spring physics engine
+ * Implements spring-damper physics for smooth, natural animations
+ */
+export declare class SpringPhysics {
+    private config;
+    /**
+     * Creates a new spring physics engine
+     * @param config - Spring configuration
+     */
+    constructor(config?: SpringConfig);
+    /**
+     * Updates spring configuration
+     * @param config - Partial config to merge with current
+     */
+    updateConfig(config: Partial<SpringConfig>): void;
+    /**
+     * Performs one physics step
+     * Uses semi-implicit Euler integration for stability
+     * @param state - Current spring state
+     * @param target - Target value
+     * @param deltaTime - Time delta in seconds
+     * @returns New spring state
+     */
+    step(state: SpringState, target: number, deltaTime: number): SpringState;
+    /**
+     * Checks if spring has reached rest state
+     * @param state - Current spring state
+     * @param target - Target value
+     * @returns True if spring is at rest
+     */
+    isAtRest(state: SpringState, target: number): boolean;
+    /**
+     * Snaps spring to target if at rest
+     * @param state - Current spring state
+     * @param target - Target value
+     * @returns Adjusted state (snapped if at rest)
+     */
+    snapIfAtRest(state: SpringState, target: number): SpringState;
+}
+//# sourceMappingURL=spring-physics.d.ts.map

package/dist/animation/spring-physics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring-physics.d.ts","sourceRoot":"","sources":["../../src/animation/spring-physics.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,wDAAwD;IACxD,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAA;IAClC;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,uBAAuB;IACvB,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,UAAU,CAAC,CAOtF,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc;IACzB,6CAA6C;;;;;;;IAE7C,6CAA6C;;;;;;;IAE7C,4DAA4D;;;;;;;IAE5D,oEAAoE;;;;;;;IAEpE,iCAAiC;;;;;;;IAEjC,gCAAgC;;;;;;;;CAExB,CAAA;AAEV;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,cAAc,CAAA;AACzD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,YAAY,CAAA;AAE5D;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAC8B;IAE5C;;;OAGG;gBACS,MAAM,GAAE,YAAiB;IAIrC;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAIjD;;;;;;;OAOG;IACH,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,WAAW;IA+BxE;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAOrD;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW;CAM9D"}