@flemo/core 1.30.0 → 2.0.0

package/dist/transition/morphTransition/createRawMorphTransition.d.ts

@@ -0,0 +1,17 @@
+import { InitialTarget } from '../cssTypes';
+import { TransitionVariantValue } from '../typing';
+import { MorphTransition, MorphTransitionName, MorphTransitionOptions } from './typing';
+interface CreateRawMorphProps {
+    name: MorphTransitionName;
+    initial: InitialTarget;
+    idle: TransitionVariantValue;
+    pushOnEnter: TransitionVariantValue;
+    pushOnExit: TransitionVariantValue;
+    replaceOnEnter: TransitionVariantValue;
+    replaceOnExit: TransitionVariantValue;
+    popOnEnter: TransitionVariantValue;
+    popOnExit: TransitionVariantValue;
+    options?: MorphTransitionOptions;
+}
+export default function createRawMorphTransition({ name, initial, idle, pushOnEnter, pushOnExit, replaceOnEnter, replaceOnExit, popOnEnter, popOnExit, options }: CreateRawMorphProps): MorphTransition;
+export {};

package/dist/transition/morphTransition/morphTransition.d.ts

@@ -0,0 +1,2 @@
+import { MorphTransition, MorphTransitionName } from './typing';
+export declare const morphTransitionMap: Map<MorphTransitionName, MorphTransition>;

package/dist/transition/morphTransition/shared.d.ts

@@ -0,0 +1,2 @@
+declare const shared: import('./typing').MorphTransition;
+export default shared;

package/dist/transition/morphTransition/text.d.ts

@@ -0,0 +1,2 @@
+declare const text: import('./typing').MorphTransition;
+export default text;

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

@@ -0,0 +1,72 @@
+import { BaseTransition, TransitionVariant } from '../typing';
+export interface RegisterMorphTransition {
+}
+export type MorphTransitionName = RegisterMorphTransition[keyof RegisterMorphTransition] | "shared" | "text" | "zoom" | (string & {});
+/** The preset every morph falls back to when no name is given. */
+export declare const DEFAULT_MORPH_TRANSITION_NAME = "shared";
+export type MorphTransitionOptions = {
+    /**
+     * The share of the flight over which the GHOST dissolves — the copy of the
+     * element being replaced that the runtime carries inside the flight (0–1,
+     * default 0.55).
+     *
+     * It is what makes a travel show the right thing at both ends: the flight
+     * begins as an exact copy of what was on glass and dissolves into the real
+     * arriving element while the box moves. Set it to 0 to carry no copy, which
+     * cuts straight to the arrival's content on the first frame.
+     *
+     * The arriving element stays opaque underneath throughout. Fading both would
+     * bleed the background through the pair by a(1 - a) — a luminance dip
+     * peaking at 25% in the middle of the hand-over.
+     *
+     * THE WINDOW IS WHAT THE DEPARTURE'S OWN CONTENT LEAVES OVER. This used to be
+     * 0.22 — three frames of a short flight — on the reasoning that holding the
+     * copy longer let the two layouts drift apart underneath it and print as
+     * doubled text. That reasoning was written when the copy painted everything,
+     * including the paired elements. It does not now: a paired descendant is
+     * already invisible in the copy (the real one is morphing underneath it), so
+     * all the copy is holding is content with NO counterpart — a caption, a body
+     * paragraph, a button that exists on one side only. Three frames is not that
+     * content leaving; it is that content being cut, which is exactly what a pop
+     * looked like next to the arrival it was supposed to reverse.
+     */
+    crossFade?: number;
+    /**
+     * Interpolate `border-radius` across the flight (default true). Nothing is
+     * scaled, so the two ends' own values are the whole story.
+     *
+     * It rides the CONTENT animation, never the geometry one: a keyframe that
+     * lists a property the compositor cannot animate drops that whole animation
+     * to the main thread, and the geometry keyframe is the one that must never
+     * leave the compositor.
+     */
+    radius?: boolean;
+    /**
+     * Move the whole screen with the element, not just the element (default off).
+     *
+     * A plain morph flies ALONE: the element crosses while the screens do
+     * whatever their own transition says, which is right when the element is one
+     * thing among many. It is wrong when the element IS the navigation — a grid
+     * cell opening into a full-screen view. There the eye reads the tap as
+     * "the camera moved to this card", and a grid that stays put underneath
+     * reads as the card escaping from it.
+     *
+     * `"screen"` gives the flight a camera: the screen the element is SMALL on
+     * (the grid — the departing screen on a push, the arriving one on a pop) is
+     * scaled and translated by exactly the zoom that takes the element from one
+     * end to the other, so every other card moves as though the viewport had
+     * pushed in on the tapped one. Material calls the pattern a container
+     * transform; iOS 18 calls its version a zoom transition.
+     *
+     * It SUPERSEDES that screen's own transform for the length of the flight —
+     * the camera IS the screen's motion here, and two authors of one transform
+     * is not a thing CSS can compose. Pair it with a transition that does not
+     * move the screen itself (`none`, or an opacity-only one); a slide would be
+     * replaced rather than combined.
+     */
+    carry?: "screen";
+};
+export interface MorphTransition extends Omit<BaseTransition, "name">, MorphTransitionOptions {
+    name: MorphTransitionName;
+}
+export declare const MORPH_FROM_VARIANT: Record<TransitionVariant, "initial" | "IDLE-true" | "self">;

package/dist/transition/morphTransition/zoom.d.ts

@@ -0,0 +1,2 @@
+declare const zoom: import('./typing').MorphTransition;
+export default zoom;

package/dist/transition/registerTransitionDefinitions.d.ts

@@ -1,4 +1,5 @@
 import { Transition } from './typing';
 import { Decorator } from './decorator/typing';
+import { MorphTransition } from './morphTransition/typing';
 import { PartTransition } from './partTransition/typing';
-export default function registerTransitionDefinitions(transitions: Transition[], decorators: Decorator[], partTransitions?: PartTransition[]): () => void;
+export default function registerTransitionDefinitions(transitions: Transition[], decorators: Decorator[], partTransitions?: PartTransition[], morphTransitions?: MorphTransition[]): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flemo/core",
-  "version": "1.30.0",
+  "version": "2.0.0",
   "description": "Framework-agnostic primitives for flemo: history, navigation, transitions, task manager.",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -33,20 +33,20 @@
   "license": "MIT",
   "dependencies": {
     "path-to-regexp": "^8.4.2",
-    "zustand": "^5.0.14"
+    "zustand": "^5.0.15"
   },
   "devDependencies": {
+    "@flemo/eslint-config": "0.0.0",
+    "@flemo/tsconfig": "0.0.0",
     "@types/node": "^24.13.1",
-    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/coverage-v8": "^4.1.11",
     "csstype": "^3.2.3",
     "eslint": "^9.39.5",
     "jsdom": "^29.1.1",
     "typescript": "^6.0.3",
-    "vite": "^8.2.1",
+    "vite": "^8.2.2",
     "vite-plugin-dts": "^5.0.3",
-    "vitest": "^4.1.10",
-    "@flemo/eslint-config": "0.0.0",
-    "@flemo/tsconfig": "0.0.0"
+    "vitest": "^4.1.11"
   },
   "publishConfig": {
     "access": "public"