@flemo/core 2.4.0 → 2.5.1

package/dist/morph/morphSheet.d.ts

@@ -1,3 +1,4 @@
+import { DeclaredFrame } from '../transition/gestureScrub';
 /**
  * Insert one flight's rules and return the disposer that removes exactly them.
  *
@@ -16,3 +17,11 @@ export declare const insertMorphRules: (rules: string[]) => (() => void);
  * A part that leads the rest of its flight is a flaw; one that jumps is a break.
  */
 export declare const ensurePinnedPoses: () => boolean;
+/**
+ * One flight's compiled path, as its emitter wrote it.
+ *
+ * `null` when the rules are not this sheet's to read — an animation from
+ * somewhere else, or a flight whose rules have already been dropped — and the
+ * caller falls back to what the animation itself reports.
+ */
+export declare const declaredMorphKeyframes: (animation: Animation) => DeclaredFrame[] | null;

package/dist/morph/morphSwipe.d.ts

@@ -6,9 +6,9 @@ export interface MorphSwipe {
      * Hand the flights back to the browser.
      *
      * `commit` plays them out to the arrival — the gesture became a navigation.
-     * Otherwise they run BACKWARDS to where they started and the elements go
-     * home, which is the only way back: a flight that is merely stopped leaves
-     * the element in the layer, outside the tree its consumer wrote.
+     * Otherwise they run their RETURN, the same path walked the other way, and
+     * the elements go home: a flight that is merely stopped leaves the element in
+     * the layer, outside the tree its consumer wrote.
      */
     settle: (commit: boolean, seconds: number) => void;
     /** Whether anything is actually flying (a screen pair with no shared element is not). */

package/dist/transition/gestureScrub.d.ts

@@ -31,3 +31,86 @@ export declare const scrubTo: (animations: readonly Animation[], clock: ScrubClo
  * explicitly instead.
  */
 export declare const settleScrubbed: (animations: readonly Animation[], clock: ScrubClock, commit: boolean, seconds: number, onReverseFinish?: () => void) => void;
+/**
+ * A time before the active interval, where `fill: forwards` contributes
+ * nothing. A leg parked here is staged, composited and inert; seeking it into
+ * range is what makes it the motion on screen.
+ */
+export declare const PARKED_MS = -1;
+type Pose = Record<string, string | number | null | undefined>;
+export interface DeclaredFrame {
+    /** Where along the animation's own clock this pose sits, 0 to 1. */
+    readonly offset: number;
+    /** The curve carried by the segment that LEAVES this frame. */
+    readonly easing: string;
+    readonly pose: Pose;
+}
+export interface ReturnLeg {
+    /** Staged with the drag, parked out of effect until the release seeks it. */
+    readonly animation: Animation;
+    /** The leg's own clock, in milliseconds: its zero is the flight's arrival. */
+    readonly duration: number;
+    /** The stretch of that clock the poses actually travel over. */
+    readonly travel: {
+        readonly start: number;
+        readonly end: number;
+    };
+    /** The curve that stretch carries, which the release inverts to seek by pose. */
+    readonly ease: AnimationOptions["ease"];
+    /** The same stretch on the SOURCE's clock, for reading where the finger left it. */
+    readonly source: {
+        readonly start: number;
+        readonly end: number;
+        readonly delay: number;
+    };
+}
+/**
+ * Stage the return of a running animation: its own path, walked the other way.
+ *
+ * The poses come back off the animation, so whatever a consumer declared —
+ * including its stops — is what the return runs. Offsets mirror, so a stop a
+ * third of the way out is a stop two thirds of the way home, and each segment
+ * keeps the curve it was given, pointing FORWARD: reversing a path must not
+ * reverse its speed, or the return would leave slowly and arrive at full tilt.
+ *
+ * The flat lead-in a flight spends before it moves is dropped from the end of
+ * the leg, so the leg finishes when the travel does rather than holding the
+ * landed pose for the length of a head nobody is waiting through.
+ *
+ * `declared` is the path as its author wrote it, for a caller that can read it
+ * back — a compiled animation must pass one, because what an engine reports
+ * through `getKeyframes` is not always all of it: Chromium answers a CSS
+ * animation with the offsets and the curves and NONE of the custom properties,
+ * and a morph's whole box travels through registered custom properties. The
+ * animation's own keyframes are the fallback, and enough for anything staged
+ * through `element.animate`.
+ *
+ * `null` when there is nothing faithful to stage — a stepped channel, which is
+ * a handover rather than a motion; a host that drops a property the source
+ * animates; an animation that never moves. Those are handed back the way they
+ * always were, by playing them backwards.
+ */
+export declare const stageReturnLeg: (source: Animation, declared?: readonly DeclaredFrame[] | null) => ReturnLeg | null;
+/**
+ * Where on the leg the pose already on screen sits, and what is left of it.
+ *
+ * The leg's path is the source's reversed, so the pose the finger left at a
+ * fraction `q` of the travel sits at `1 - q` along it — through the curve,
+ * which is why this inverts rather than mirrors the time.
+ *
+ * `null` when there is nothing left to fly.
+ */
+export declare const returnLegSeek: (leg: ReturnLeg, source: Animation) => {
+    at: number;
+    remaining: number;
+} | null;
+/**
+ * Put a staged leg at the pose already on screen and let it run.
+ *
+ * `remaining` of the leg's own clock covers the release's `seconds`, which is
+ * what makes a leg staged for the flight's length land in the time the release
+ * settled on. Nothing here builds or reshapes an effect — the leg was staged
+ * with the drag — so the frame the finger lifts has no animation to commit.
+ */
+export declare const placeLeg: (leg: Animation, at: number, remaining: number, seconds: number) => void;
+export {};

package/dist/transition/partTransition/createPartTransition.d.ts

@@ -6,7 +6,8 @@ interface CreatePartProps {
     idle: PartVariantValue;
     enter: PartVariantValue;
     exit: PartVariantValue;
+    dismiss?: PartVariantValue;
     options?: PartTransitionOptions;
 }
-export default function createPartTransition({ name, initial, idle, enter, exit, options }: CreatePartProps): PartTransition;
+export default function createPartTransition({ name, initial, idle, enter, exit, dismiss, options }: CreatePartProps): PartTransition;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flemo/core",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "Framework-agnostic primitives for flemo: history, navigation, transitions, task manager.",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -39,14 +39,14 @@
     "@flemo/eslint-config": "0.0.0",
     "@flemo/tsconfig": "0.0.0",
     "@types/node": "^24.13.1",
-    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/coverage-v8": "^5.0.0",
     "csstype": "^3.2.3",
     "eslint": "^9.39.5",
-    "jsdom": "^29.1.1",
+    "jsdom": "^30.0.1",
     "typescript": "^6.0.3",
     "vite": "^8.2.2",
     "vite-plugin-dts": "^5.1.0",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/core/engine/__tests__/compositorWarmUp.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/engine/compositorWarmUp.d.ts

@@ -1,3 +0,0 @@
-export { WARM_ATTR } from '../../dom/attributes';
-export declare const resetCompositorWarmForTesting: () => void;
-export default function holdCompositorWarm(): () => void;