@flemo/core 2.0.0 → 2.1.0

package/dist/morph/attachMorph.d.ts

@@ -46,6 +46,20 @@ interface MorphFlight {
  * stage a flight the runtime does not clock.
  */
 export declare const stageHeldFlights: (store: NavigateStoreApi, status: NavigateStatus) => MorphFlight[];
+/**
+ * Forget any delivery the navigation never came to collect. A NEW gesture
+ * supersedes the last one; only the gesture's own entry point may do this,
+ * because the navigation reaches the scope through `stageHeldFlights` too and
+ * clearing there would erase the mark a moment before reading it.
+ */
+/**
+ * Record that a gesture's release has DELIVERED whatever it is carrying — it
+ * plays those flights out to the arrival itself, so the navigation it commits
+ * must not stage them again. Whatever is in the air at the release is exactly
+ * what the gesture delivers. See `MorphScope.delivered`.
+ */
+export declare const clearGestureDeliveries: (store: NavigateStoreApi) => void;
+export declare const markGestureDelivered: (store: NavigateStoreApi) => void;
 /** The flights a scope currently holds — the nested ones included. */
 export declare const heldFlights: (store: NavigateStoreApi) => MorphFlight[];
 export type { MorphFlight };

package/dist/screen/__tests__/publishRideBox.test.d.ts

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

package/dist/screen/publishRideBox.d.ts

@@ -0,0 +1 @@
+export default function publishRideBox(element: HTMLElement): () => void;

package/dist/transition/__tests__/compileTransitionStyles.test.d.ts

@@ -1,5 +1,6 @@
 declare module '../typing' {
     interface RegisterTransition {
+        "custom-snap-percent": "custom-snap-percent";
         "custom-fade-blur": "custom-fade-blur";
         "custom-slide-fade": "custom-slide-fade";
         "custom-rich-css": "custom-rich-css";
@@ -13,6 +14,7 @@ declare module '../decorator/typing' {
     interface RegisterDecorator {
         "rich-deco": "rich-deco";
         "held-deco": "held-deco";
+        "moving-deco": "moving-deco";
         "authored-deco": "authored-deco";
     }
 }

package/dist/transition/__tests__/rideOffset.test.d.ts

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

package/dist/transition/compileTransitionStyles.d.ts

@@ -7,9 +7,10 @@ export type CssDecl = {
     value: string;
 };
 export declare const collectAnimatedProperties: (transition: Pick<Transition, "initial" | "variants">) => string[];
-export declare const targetToDecls: (target: TransitionVariantValue["value"] | InitialTarget) => CssDecl[];
+export declare const targetToDecls: (target: TransitionVariantValue["value"] | InitialTarget, ride?: boolean) => CssDecl[];
 export declare const easingToCss: (ease: AnimationOptions["ease"] | undefined) => string;
 export declare const animationName: (scope: "screen" | "decorator" | "part", name: string, variant: TransitionVariant) => string;
+export declare const decoratorAnimationName: (transitionName: string, decoratorName: string, variant: TransitionVariant) => string;
 export declare const HEAD_ANIMATION_SUFFIXES: readonly ["-gov", "-deskhead", "-govcreep"];
 export declare const matchesFlightAnimationName: (eventName: string, expectedName: string) => boolean;
 export declare const compileTransitionStyles: (transitions: Iterable<Transition>, decorators: Iterable<Decorator>, partTransitions?: Iterable<PartTransition>) => string;

package/dist/transition/decorator/__tests__/resolveDecoratorClock.test.d.ts

@@ -0,0 +1,14 @@
+declare module '../../typing' {
+    interface RegisterTransition {
+        "clock-long": "clock-long";
+        "clock-short": "clock-short";
+        "clock-directional": "clock-directional";
+    }
+}
+declare module '../typing' {
+    interface RegisterDecorator {
+        "clock-dim": "clock-dim";
+        "clock-fixed": "clock-fixed";
+    }
+}
+export {};

package/dist/transition/decorator/createDecorator.d.ts

@@ -1,12 +1,11 @@
 import { InitialTarget } from '../cssTypes';
-import { TransitionVariantValue } from '../typing';
-import { DecoratorName, Decorator, DecoratorOptions } from './typing';
+import { DecoratorName, Decorator, DecoratorOptions, DecoratorVariantValue } from './typing';
 interface CreateDecoratorProps {
     name: DecoratorName;
     initial: InitialTarget;
-    idle: TransitionVariantValue;
-    enter: TransitionVariantValue;
-    exit: TransitionVariantValue;
+    idle: DecoratorVariantValue;
+    enter: DecoratorVariantValue;
+    exit: DecoratorVariantValue;
     options?: DecoratorOptions;
 }
 export default function createDecorator({ name, initial, idle, enter, exit, options }: CreateDecoratorProps): Decorator;

package/dist/transition/decorator/createRawDecorator.d.ts

@@ -1,18 +1,17 @@
 import { InitialTarget } from '../cssTypes';
-import { TransitionVariantValue } from '../typing';
-import { DecoratorName, Decorator, DecoratorOptions } from './typing';
+import { DecoratorName, Decorator, DecoratorOptions, DecoratorVariantValue } from './typing';
 interface CreateRawDecoratorProps {
     name: DecoratorName;
     initial: InitialTarget;
-    idle: TransitionVariantValue;
-    pushOnEnter: TransitionVariantValue;
-    pushOnExit: TransitionVariantValue;
-    replaceOnEnter: TransitionVariantValue;
-    replaceOnExit: TransitionVariantValue;
-    popOnEnter: TransitionVariantValue;
-    popOnExit: TransitionVariantValue;
-    completedOnEnter: TransitionVariantValue;
-    completedOnExit: TransitionVariantValue;
+    idle: DecoratorVariantValue;
+    pushOnEnter: DecoratorVariantValue;
+    pushOnExit: DecoratorVariantValue;
+    replaceOnEnter: DecoratorVariantValue;
+    replaceOnExit: DecoratorVariantValue;
+    popOnEnter: DecoratorVariantValue;
+    popOnExit: DecoratorVariantValue;
+    completedOnEnter: DecoratorVariantValue;
+    completedOnExit: DecoratorVariantValue;
     options?: DecoratorOptions;
 }
 export default function createRawDecorator({ name, initial, idle, pushOnEnter, pushOnExit, replaceOnEnter, replaceOnExit, popOnEnter, popOnExit, completedOnEnter, completedOnExit, options }: CreateRawDecoratorProps): Decorator;

package/dist/transition/decorator/resolveDecoratorClock.d.ts

@@ -0,0 +1,36 @@
+import { BaseTransition, Transition } from '../typing';
+import { Decorator } from './typing';
+/**
+ * A decorator's variant table with its clock filled in from the screen
+ * transition that names it.
+ *
+ * A decorator is only ever reached through `transition.decoratorName`, so the
+ * flight it dresses already decides how long it has. Authoring the length a
+ * second time is how the two drift apart, and this repository worked around
+ * that three times before removing the duplication:
+ *
+ *   - `overlay` and `cupertino` each restated 0.7s, with a comment on the
+ *     decorator saying the number came from the transition.
+ *   - the playground's `drift` and `recess` share a constants file for no
+ *     other reason than to keep two hand-written clocks equal.
+ *   - `layout` dropped its dim ALTOGETHER rather than inherit `overlay`'s
+ *     0.7s over a 0.4s flight: measured on a pop, the dismissing screen was
+ *     fully gone at 335ms while the screen underneath still carried a 10%
+ *     black wash, which reads as a grey cast appearing from nowhere and then
+ *     lifting for no reason.
+ *
+ * The rule is the SAME VARIANT KEY, which is exactly the mapping those
+ * workarounds were doing by hand: a decorator's `enter` sits at PUSHING-false
+ * with the screen's `exit`, its `exit` at POPPING-false with the screen's
+ * `exitBack`. It therefore also carries direction for free — a preset whose
+ * push and pop differ (material runs 0.35s and 0.25s) gives its dim the same
+ * asymmetry without the author restating it.
+ *
+ * Resolution is COMPILE TIME and produces a literal. It must never become a
+ * `var()` in `animation-duration`: timing that depended on custom properties
+ * lost WebKit's accelerated playback and collapsed to a 2-frame snap under
+ * main-thread starvation (device-bisected 2026-08-13, see
+ * compileTransitionStyles.ts).
+ */
+export declare const resolveDecoratorClock: (transition: Pick<Transition, "variants">, decorator: Pick<Decorator, "initial" | "variants">) => Pick<BaseTransition, "initial" | "variants">;
+export default resolveDecoratorClock;

package/dist/transition/decorator/typing.d.ts

@@ -1,4 +1,5 @@
-import { BaseTransition, SwipeAnimate } from '../typing';
+import { AnimationOptions, TransitionTarget } from '../cssTypes';
+import { BaseTransition, SwipeAnimate, TransitionVariant } from '../typing';
 export interface RegisterDecorator {
 }
 export type DecoratorName = RegisterDecorator[keyof RegisterDecorator] | "overlay";
@@ -19,6 +20,11 @@ export type DecoratorOptions = {
         prevDecorator: HTMLDivElement;
     }) => void;
 };
-export interface Decorator extends Omit<BaseTransition, "name">, DecoratorOptions {
+export type DecoratorVariantValue = {
+    value: TransitionTarget;
+    options?: AnimationOptions;
+};
+export interface Decorator extends Omit<BaseTransition, "name" | "variants">, DecoratorOptions {
     name: DecoratorName;
+    variants: Record<TransitionVariant, DecoratorVariantValue>;
 }

package/dist/transition/rideOffset.d.ts

@@ -0,0 +1,5 @@
+import { TransitionTarget } from './cssTypes';
+export declare const RIDE_HEIGHT_VAR = "--flemo-ride-y";
+export declare const percentRatio: (value: unknown) => number | null;
+export declare const rideLength: (ratio: number) => string;
+export declare const resolveRideTarget: <T extends TransitionTarget>(target: T, screenHeight: number) => T;

package/dist/transition/swipeSettle.d.ts

@@ -29,8 +29,12 @@ export interface SwipeSettleInput {
      * time that curve itself spends on the stretch that is left; without them it
      * falls back to reading the motion as linear, which is what this used to do
      * for every transition.
+     *
+     * `null` is accepted as well as omission, because the callers that build
+     * this read their curve from `easeControlPoints`, which reports "no curve"
+     * as null. Converting at every call site bought nothing but a branch.
      */
-    authoredEase?: readonly [number, number, number, number];
+    authoredEase?: readonly [number, number, number, number] | null;
     minSeconds?: number;
 }
 /**

package/dist/transition/typing.d.ts

@@ -42,7 +42,18 @@ export type TransitionOptions = {
         animate: SwipeAnimate;
         currentScreen: HTMLDivElement;
         prevScreen: HTMLDivElement;
-        onProgress?: (triggered: boolean, progress: number) => void;
+        /**
+         * Report the gesture's VERDICT so the decorator and the parts can
+         * follow it. The controller supplies their progress itself, against
+         * the box the screen is actually dragged over, so a second argument
+         * is accepted for source compatibility and is not read.
+         *
+         * It used to be. A transition's own progress is in the transition's
+         * own unit — material's is a pull in pixels, layout's is a constant
+         * — so what reached a decorator depended on which preset it was
+         * paired with, and could not honour the 0-100 those hooks document.
+         */
+        onProgress?: (triggered: boolean, progress?: number) => void;
     }) => number;
     onSwipeEnd: (event: PointerEvent, info: SwipeInfo, options: {
         animate: SwipeAnimate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flemo/core",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Framework-agnostic primitives for flemo: history, navigation, transitions, task manager.",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",