@replayablejs/tween 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Replayable contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @replayablejs/tween
+
+Animate DOM elements and object properties using lifecycle-aware Motion playback.
+
+Part of [Replayable](https://github.com/replayablejs/replayable) **0.1.0-alpha.0**.
+APIs may change during the alpha series.
+
+## Install
+
+```sh
+pnpm add @replayablejs/tween@0.1.0-alpha.0
+```
+
+## Public surface
+
+`animate`, `stagger`, `TweenPlaybackControls`.
+
+[Usage and reference](https://github.com/replayablejs/replayable/blob/main/docs/reference/tween.md).
+The package manifest defines supported import paths; internal source files are not public APIs.
+
+## Development
+
+From the repository root, install with `pnpm install --frozen-lockfile` and build dependencies
+with `pnpm build`. Run `pnpm --filter @replayablejs/tween test` for this package's tests.
+
+## Peer dependencies
+
+- `@replayablejs/runtime`: `workspace:*`
+
+Workspace ranges are converted to package versions when packed.
+
+## License
+
+Original code is [MIT licensed](https://github.com/replayablejs/replayable/blob/main/LICENSE). Bundled third-party resources retain
+their accompanying license terms.

package/dist/index.d.ts

@@ -0,0 +1,53 @@
+import { AnimationOptions, AnimationSequence, DOMKeyframesDefinition, ElementOrSelector, MotionValue, ObjectTarget, SequenceOptions, UnresolvedValueKeyframe, ValueAnimationTransition, stagger } from "motion";
+//#region src/types/playback.d.ts
+/** Public controls for one tween created through `@replayablejs/tween`. */
+interface TweenPlaybackControls {
+  /** Current animation position in seconds. Assigning a value seeks the tween. */
+  time: number;
+  /** Playback-rate multiplier, where `1` is normal speed and `-1` plays in reverse. */
+  speed: number;
+  /** Total animation duration in seconds. */
+  readonly duration: number;
+  /** Resumes playback from the current position. */
+  play(): void;
+  /** Pauses playback at the current position. */
+  pause(): void;
+  /** Stops playback permanently at its current visual state. */
+  stop(): void;
+  /** Cancels playback and restores its initial state. */
+  cancel(): void;
+  /** Finishes playback immediately and applies its final state. */
+  complete(): void;
+  /**
+   * Makes the controls awaitable and resolves after normal or forced completion.
+   *
+   * @example
+   *
+   * ```ts
+   * const controls = animate(element, { opacity: 1 });
+   * await controls;
+   * ```
+   */
+  then(onResolve: () => void, onReject?: () => void): Promise<void>;
+}
+//#endregion
+//#region src/animate.d.ts
+/**
+ * Animates values through Motion while applying Replayable's host lifecycle.
+ *
+ * The overloads intentionally mirror Motion's hybrid `animate()` function:
+ * sequences, individual values, Motion values, DOM/SVG targets, and plain
+ * objects all retain their native keyframe and option inference. Only the
+ * returned controls are narrowed to Replayable's stable public contract.
+ *
+ * @throws When called before `await playable.ready()`.
+ */
+declare function animate(sequence: AnimationSequence, options?: SequenceOptions): TweenPlaybackControls;
+declare function animate(value: string | MotionValue<string>, keyframes: string | UnresolvedValueKeyframe<string>[], options?: ValueAnimationTransition<string>): TweenPlaybackControls;
+declare function animate(value: number | MotionValue<number>, keyframes: number | UnresolvedValueKeyframe<number>[], options?: ValueAnimationTransition<number>): TweenPlaybackControls;
+declare function animate<Value extends string | number>(value: Value | MotionValue<Value>, keyframes: Value | UnresolvedValueKeyframe<Value>[], options?: ValueAnimationTransition<Value>): TweenPlaybackControls;
+declare function animate(element: ElementOrSelector, keyframes: DOMKeyframesDefinition, options?: AnimationOptions): TweenPlaybackControls;
+declare function animate<Object extends object>(object: Object | Object[], keyframes: ObjectTarget<Object>, options?: AnimationOptions): TweenPlaybackControls;
+//#endregion
+export { type TweenPlaybackControls, animate, stagger };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,230 @@
+import { animate as animate$1, stagger } from "motion";
+import { playable } from "@replayablejs/runtime";
+//#region src/lifecycle/create-managed-tween.ts
+/**
+* Wraps one Motion animation while preserving playback intent across visibility.
+*
+* Visibility retains only running children; finished children stay finished.
+* An explicit hidden-time `play()` instead requests playback of the whole group.
+* Manual pause or termination clears both forms of deferred playback intent.
+*/
+function createManagedTween(motionControls, animations, isVisible, registry) {
+	const pausedForVisibility = /* @__PURE__ */ new Set();
+	let playWhenVisible = false;
+	let stopped = false;
+	return {
+		get hasDeferredPlay() {
+			return playWhenVisible;
+		},
+		controls: {
+			get duration() {
+				return motionControls.duration;
+			},
+			get speed() {
+				return motionControls.speed;
+			},
+			set speed(speed) {
+				motionControls.speed = speed;
+			},
+			get time() {
+				return motionControls.time;
+			},
+			set time(time) {
+				motionControls.time = time;
+			},
+			cancel() {
+				terminate("cancel");
+			},
+			complete() {
+				terminate("complete");
+			},
+			pause() {
+				clearVisibilityIntent();
+				motionControls.pause();
+			},
+			play() {
+				if (stopped) return;
+				if (!isVisible()) {
+					playWhenVisible = true;
+					registry.retain();
+					return;
+				}
+				clearVisibilityIntent();
+				motionControls.play();
+				registry.trackPlayback();
+			},
+			stop() {
+				stopped = true;
+				terminate("stop");
+			},
+			then(onResolve, onReject) {
+				return motionControls.then(onResolve, onReject);
+			}
+		},
+		/** Pauses a running tween without changing the application's play intent. */
+		pauseForVisibility() {
+			for (const animation of animations) if (animation.state === "running") {
+				animation.pause();
+				pausedForVisibility.add(animation);
+			}
+		},
+		/** Resumes only playback that Replayable deferred because the host was hidden. */
+		resumeFromVisibility() {
+			if (playWhenVisible) {
+				clearVisibilityIntent();
+				motionControls.play();
+				registry.trackPlayback();
+				return;
+			}
+			if (pausedForVisibility.size === 0) return;
+			for (const animation of pausedForVisibility) animation.play();
+			pausedForVisibility.clear();
+			registry.trackPlayback();
+		}
+	};
+	/** Removes deferred intent before invoking any potentially reentrant Motion callback. */
+	function clearVisibilityIntent() {
+		playWhenVisible = false;
+		pausedForVisibility.clear();
+	}
+	/**
+	* Attempts every child before releasing registry ownership. A throwing Motion
+	* callback must not skip later children or retain this terminated tween.
+	*/
+	function terminate(operation) {
+		clearVisibilityIntent();
+		const errors = [];
+		for (const animation of animations) try {
+			animation[operation]();
+		} catch (error) {
+			errors.push(error);
+		}
+		registry.release();
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, `Unable to ${operation} every tween animation.`);
+	}
+}
+//#endregion
+//#region src/lifecycle/create-playback-observer.ts
+/**
+* Observes child completion promises, not Motion's fresh aggregate per getter.
+* Pausing/resuming keeps these promises, so it adds no completion subscriptions.
+* Replaying a finished child replaces its promise and starts a new observation.
+*/
+function createPlaybackObserver(animations, onComplete) {
+	let observed;
+	return {
+		observe,
+		clear
+	};
+	/** Subscribes only when at least one child has entered a new playback cycle. */
+	function observe() {
+		const completions = animations.map((animation) => animation.finished);
+		if (observed?.every((completion, index) => completion === completions[index])) return;
+		observed = completions;
+		Promise.all(completions).then(handleComplete, handleComplete);
+		/** An older playback must never release a newer or explicitly terminated one. */
+		function handleComplete() {
+			if (observed !== completions) return;
+			observed = void 0;
+			onComplete();
+		}
+	}
+	/** Discards ownership without trying to cancel Motion's native promises. */
+	function clear() {
+		observed = void 0;
+	}
+}
+//#endregion
+//#region src/lifecycle/resolve-motion-animations.ts
+/**
+* Resolves the individual animations behind Motion's public group controls.
+*
+* Motion 13 groups expose `animations`, but their `state` getter reports only
+* the first child. Lifecycle decisions must inspect children independently:
+* one property can finish while another continues or repeats indefinitely.
+* Keep this integration boundary aligned with Motion when upgrading it.
+*/
+function resolveMotionAnimations(controls) {
+	return controls.animations?.flatMap(resolveMotionAnimations) ?? [controls];
+}
+//#endregion
+//#region src/lifecycle/create-tween-lifecycle.ts
+let tweenLifecycle;
+/**
+* Returns the shared lifecycle registry, creating it on the first animation.
+*
+* `animate()` calls this before invoking Motion. The initial `playable.state`
+* read therefore rejects animation creation before `await playable.ready()`
+* without leaving an untracked Motion animation running in the background.
+*/
+function getTweenLifecycle() {
+	tweenLifecycle ??= createTweenLifecycle(playable);
+	return tweenLifecycle;
+}
+/**
+* Creates the lifecycle registry shared by every tween in one playable.
+*
+* Creation reads `playable.state`, which intentionally throws when application
+* code requests an animation before `await playable.ready()`. Its single
+* visibility subscription then lives with this singleton for the lifetime of
+* the playable; completed tweens are still removed from the active registry.
+*/
+function createTweenLifecycle(runtime) {
+	const managedTweens = /* @__PURE__ */ new Set();
+	let visible = runtime.state.visible;
+	runtime.on("visibilitychange", handleVisibilityChange);
+	return { 
+	/** Wraps one newly created Motion animation in Replayable's public controls. */
+manage(motionControls) {
+		const animations = resolveMotionAnimations(motionControls);
+		const observer = createPlaybackObserver(animations, handleComplete);
+		const managedTween = createManagedTween(motionControls, animations, () => visible, {
+			release,
+			retain,
+			trackPlayback
+		});
+		trackPlayback();
+		if (!visible) managedTween.pauseForVisibility();
+		return managedTween.controls;
+		/** Deferred replay survives settlement of the previous playback cycle. */
+		function handleComplete() {
+			if (!managedTween.hasDeferredPlay) release();
+		}
+		/** Visibility deferral keeps ownership without adding completion observers. */
+		function retain() {
+			managedTweens.add(managedTween);
+		}
+		/** Retains playback and observes it only if its child promises changed. */
+		function trackPlayback() {
+			retain();
+			observer.observe();
+		}
+		/** Invalidates older completion callbacks and forgets terminated playback. */
+		function release() {
+			observer.clear();
+			managedTweens.delete(managedTween);
+		}
+	} };
+	/** Applies one committed host-visibility transition to every active tween. */
+	function handleVisibilityChange(nextVisible) {
+		visible = nextVisible;
+		const operation = visible ? "resumeFromVisibility" : "pauseForVisibility";
+		for (const managedTween of managedTweens) managedTween[operation]();
+	}
+}
+//#endregion
+//#region src/animate.ts
+function animate(subjectOrSequence, keyframesOrOptions, options) {
+	const lifecycle = getTweenLifecycle();
+	const motionControls = Reflect.apply(animate$1, void 0, [
+		subjectOrSequence,
+		keyframesOrOptions,
+		options
+	]);
+	return lifecycle.manage(motionControls);
+}
+//#endregion
+export { animate, stagger };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["motionAnimate"],"sources":["../src/lifecycle/create-managed-tween.ts","../src/lifecycle/create-playback-observer.ts","../src/lifecycle/resolve-motion-animations.ts","../src/lifecycle/create-tween-lifecycle.ts","../src/animate.ts"],"sourcesContent":["import type { ManagedTween, ManagedTweenRegistry, TweenTermination } from '#types/lifecycle.js';\nimport type { MotionAnimation, MotionPlaybackControls } from '#types/motion-playback.js';\nimport type { TweenPlaybackControls } from '#types/playback.js';\n\n/**\n * Wraps one Motion animation while preserving playback intent across visibility.\n *\n * Visibility retains only running children; finished children stay finished.\n * An explicit hidden-time `play()` instead requests playback of the whole group.\n * Manual pause or termination clears both forms of deferred playback intent.\n */\nexport function createManagedTween(\n  motionControls: MotionPlaybackControls,\n  animations: readonly MotionAnimation[],\n  isVisible: () => boolean,\n  registry: ManagedTweenRegistry,\n): ManagedTween {\n  const pausedForVisibility = new Set<MotionAnimation>();\n  let playWhenVisible = false;\n  let stopped = false;\n\n  return {\n    get hasDeferredPlay(): boolean {\n      return playWhenVisible;\n    },\n    controls: {\n      get duration(): number {\n        return motionControls.duration;\n      },\n\n      get speed(): number {\n        return motionControls.speed;\n      },\n\n      set speed(speed: number) {\n        motionControls.speed = speed;\n      },\n\n      get time(): number {\n        return motionControls.time;\n      },\n\n      set time(time: number) {\n        motionControls.time = time;\n      },\n\n      cancel(): void {\n        terminate('cancel');\n      },\n\n      complete(): void {\n        terminate('complete');\n      },\n\n      pause(): void {\n        clearVisibilityIntent();\n        motionControls.pause();\n      },\n\n      play(): void {\n        // Motion permanently detaches stopped animations; a later play() is a\n        // no-op and must not reintroduce dead controls into the active registry.\n        if (stopped) {\n          return;\n        }\n\n        if (!isVisible()) {\n          playWhenVisible = true;\n          registry.retain();\n          return;\n        }\n\n        clearVisibilityIntent();\n        motionControls.play();\n        registry.trackPlayback();\n      },\n\n      stop(): void {\n        stopped = true;\n        terminate('stop');\n      },\n\n      then(onResolve, onReject): Promise<void> {\n        return motionControls.then(onResolve, onReject);\n      },\n    } satisfies TweenPlaybackControls,\n\n    /** Pauses a running tween without changing the application's play intent. */\n    pauseForVisibility(): void {\n      for (const animation of animations) {\n        if (animation.state === 'running') {\n          animation.pause();\n          pausedForVisibility.add(animation);\n        }\n      }\n    },\n\n    /** Resumes only playback that Replayable deferred because the host was hidden. */\n    resumeFromVisibility(): void {\n      if (playWhenVisible) {\n        clearVisibilityIntent();\n        motionControls.play();\n        registry.trackPlayback();\n        return;\n      }\n\n      if (pausedForVisibility.size === 0) {\n        return;\n      }\n\n      for (const animation of pausedForVisibility) {\n        animation.play();\n      }\n      pausedForVisibility.clear();\n      registry.trackPlayback();\n    },\n  };\n\n  /** Removes deferred intent before invoking any potentially reentrant Motion callback. */\n  function clearVisibilityIntent(): void {\n    playWhenVisible = false;\n    pausedForVisibility.clear();\n  }\n\n  /**\n   * Attempts every child before releasing registry ownership. A throwing Motion\n   * callback must not skip later children or retain this terminated tween.\n   */\n  function terminate(operation: TweenTermination): void {\n    clearVisibilityIntent();\n    const errors: unknown[] = [];\n    for (const animation of animations) {\n      try {\n        animation[operation]();\n      } catch (error) {\n        errors.push(error);\n      }\n    }\n    registry.release();\n\n    if (errors.length === 1) {\n      throw errors[0];\n    }\n    if (errors.length > 1) {\n      throw new AggregateError(errors, `Unable to ${operation} every tween animation.`);\n    }\n  }\n}\n","import type { PlaybackObserver } from '#types/lifecycle.js';\nimport type { MotionAnimation } from '#types/motion-playback.js';\n\n/**\n * Observes child completion promises, not Motion's fresh aggregate per getter.\n * Pausing/resuming keeps these promises, so it adds no completion subscriptions.\n * Replaying a finished child replaces its promise and starts a new observation.\n */\nexport function createPlaybackObserver(\n  animations: readonly MotionAnimation[],\n  onComplete: () => void,\n): PlaybackObserver {\n  let observed: readonly Promise<void>[] | undefined;\n\n  return { observe, clear };\n\n  /** Subscribes only when at least one child has entered a new playback cycle. */\n  function observe(): void {\n    const completions = animations.map((animation) => animation.finished);\n    if (observed?.every((completion, index) => completion === completions[index])) {\n      return;\n    }\n\n    observed = completions;\n    void Promise.all(completions).then(handleComplete, handleComplete);\n\n    /** An older playback must never release a newer or explicitly terminated one. */\n    function handleComplete(): void {\n      if (observed !== completions) {\n        return;\n      }\n      observed = undefined;\n      onComplete();\n    }\n  }\n\n  /** Discards ownership without trying to cancel Motion's native promises. */\n  function clear(): void {\n    observed = undefined;\n  }\n}\n","import type { MotionAnimation } from '#types/motion-playback.js';\n\n/**\n * Resolves the individual animations behind Motion's public group controls.\n *\n * Motion 13 groups expose `animations`, but their `state` getter reports only\n * the first child. Lifecycle decisions must inspect children independently:\n * one property can finish while another continues or repeats indefinitely.\n * Keep this integration boundary aligned with Motion when upgrading it.\n */\nexport function resolveMotionAnimations(controls: MotionAnimation): readonly MotionAnimation[] {\n  return controls.animations?.flatMap(resolveMotionAnimations) ?? [controls];\n}\n","import { playable } from '@replayablejs/runtime';\n\nimport { createManagedTween } from '#lifecycle/create-managed-tween.js';\nimport { createPlaybackObserver } from '#lifecycle/create-playback-observer.js';\nimport { resolveMotionAnimations } from '#lifecycle/resolve-motion-animations.js';\nimport type { ManagedTween, TweenLifecycle, TweenRuntime } from '#types/lifecycle.js';\nimport type { MotionPlaybackControls } from '#types/motion-playback.js';\nimport type { TweenPlaybackControls } from '#types/playback.js';\n\nlet tweenLifecycle: TweenLifecycle | undefined;\n\n/**\n * Returns the shared lifecycle registry, creating it on the first animation.\n *\n * `animate()` calls this before invoking Motion. The initial `playable.state`\n * read therefore rejects animation creation before `await playable.ready()`\n * without leaving an untracked Motion animation running in the background.\n */\nexport function getTweenLifecycle(): TweenLifecycle {\n  tweenLifecycle ??= createTweenLifecycle(playable);\n\n  return tweenLifecycle;\n}\n\n/**\n * Creates the lifecycle registry shared by every tween in one playable.\n *\n * Creation reads `playable.state`, which intentionally throws when application\n * code requests an animation before `await playable.ready()`. Its single\n * visibility subscription then lives with this singleton for the lifetime of\n * the playable; completed tweens are still removed from the active registry.\n */\nexport function createTweenLifecycle(runtime: TweenRuntime): TweenLifecycle {\n  const managedTweens = new Set<ManagedTween>();\n  let visible = runtime.state.visible;\n\n  // A playable owns one lifecycle for its entire document lifetime. Retaining\n  // this single listener is simpler than repeatedly subscribing between tweens.\n  runtime.on('visibilitychange', handleVisibilityChange);\n\n  return {\n    /** Wraps one newly created Motion animation in Replayable's public controls. */\n    manage(motionControls: MotionPlaybackControls): TweenPlaybackControls {\n      const animations = resolveMotionAnimations(motionControls);\n      const observer = createPlaybackObserver(animations, handleComplete);\n      const managedTween = createManagedTween(motionControls, animations, () => visible, {\n        release,\n        retain,\n        trackPlayback,\n      });\n\n      trackPlayback();\n\n      if (!visible) {\n        managedTween.pauseForVisibility();\n      }\n\n      return managedTween.controls;\n\n      /** Deferred replay survives settlement of the previous playback cycle. */\n      function handleComplete(): void {\n        if (!managedTween.hasDeferredPlay) {\n          release();\n        }\n      }\n\n      /** Visibility deferral keeps ownership without adding completion observers. */\n      function retain(): void {\n        managedTweens.add(managedTween);\n      }\n\n      /** Retains playback and observes it only if its child promises changed. */\n      function trackPlayback(): void {\n        retain();\n        observer.observe();\n      }\n\n      /** Invalidates older completion callbacks and forgets terminated playback. */\n      function release(): void {\n        observer.clear();\n        managedTweens.delete(managedTween);\n      }\n    },\n  };\n\n  /** Applies one committed host-visibility transition to every active tween. */\n  function handleVisibilityChange(nextVisible: boolean): void {\n    visible = nextVisible;\n    const operation = visible ? 'resumeFromVisibility' : 'pauseForVisibility';\n\n    for (const managedTween of managedTweens) {\n      managedTween[operation]();\n    }\n  }\n}\n","import {\n  animate as motionAnimate,\n  type AnimationOptions,\n  type AnimationPlaybackControlsWithThen,\n  type AnimationSequence,\n  type DOMKeyframesDefinition,\n  type ElementOrSelector,\n  type MotionValue,\n  type ObjectTarget,\n  type SequenceOptions,\n  type UnresolvedValueKeyframe,\n  type ValueAnimationTransition,\n} from 'motion';\n\nimport { getTweenLifecycle } from '#lifecycle/create-tween-lifecycle.js';\nimport type { TweenPlaybackControls } from '#types/playback.js';\n\n/**\n * Animates values through Motion while applying Replayable's host lifecycle.\n *\n * The overloads intentionally mirror Motion's hybrid `animate()` function:\n * sequences, individual values, Motion values, DOM/SVG targets, and plain\n * objects all retain their native keyframe and option inference. Only the\n * returned controls are narrowed to Replayable's stable public contract.\n *\n * @throws When called before `await playable.ready()`.\n */\nexport function animate(\n  sequence: AnimationSequence,\n  options?: SequenceOptions,\n): TweenPlaybackControls;\nexport function animate(\n  value: string | MotionValue<string>,\n  keyframes: string | UnresolvedValueKeyframe<string>[],\n  options?: ValueAnimationTransition<string>,\n): TweenPlaybackControls;\nexport function animate(\n  value: number | MotionValue<number>,\n  keyframes: number | UnresolvedValueKeyframe<number>[],\n  options?: ValueAnimationTransition<number>,\n): TweenPlaybackControls;\nexport function animate<Value extends string | number>(\n  value: Value | MotionValue<Value>,\n  keyframes: Value | UnresolvedValueKeyframe<Value>[],\n  options?: ValueAnimationTransition<Value>,\n): TweenPlaybackControls;\nexport function animate(\n  element: ElementOrSelector,\n  keyframes: DOMKeyframesDefinition,\n  options?: AnimationOptions,\n): TweenPlaybackControls;\nexport function animate<Object extends object>(\n  object: Object | Object[],\n  keyframes: ObjectTarget<Object>,\n  options?: AnimationOptions,\n): TweenPlaybackControls;\nexport function animate(\n  subjectOrSequence: unknown,\n  keyframesOrOptions?: unknown,\n  options?: unknown,\n): TweenPlaybackControls {\n  // Readiness is checked before Motion creates a running animation, ensuring a\n  // rejected early call cannot leave untracked browser work behind.\n  const lifecycle = getTweenLifecycle();\n  const motionControls: AnimationPlaybackControlsWithThen = Reflect.apply(\n    motionAnimate,\n    undefined,\n    [subjectOrSequence, keyframesOrOptions, options],\n  );\n\n  return lifecycle.manage(motionControls);\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@replayablejs/tween",
+  "version": "0.1.0-alpha.0",
+  "description": "Lifecycle-aware animation for Replayable playable ads",
+  "homepage": "https://github.com/replayablejs/replayable#readme",
+  "bugs": {
+    "url": "https://github.com/replayablejs/replayable/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/replayablejs/replayable.git",
+    "directory": "packages/tween"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "imports": {
+    "#lifecycle/*": "./src/lifecycle/*",
+    "#types/*": "./src/types/*"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "motion": "13.1.1"
+  },
+  "devDependencies": {
+    "tsdown": "0.22.14",
+    "typescript": "7.0.2",
+    "vitest": "4.1.10",
+    "@replayablejs/runtime": "0.1.0-alpha.0"
+  },
+  "peerDependencies": {
+    "@replayablejs/runtime": "0.1.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "oxlint --type-aware --max-warnings 0 .",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}