{"version":3,"file":"start.mjs","sources":["../../../src/view/start.ts"],"sourcesContent":["import { secondsToMilliseconds, warnOnce } from \"motion-utils\"\nimport { GroupAnimation } from \"../animation/GroupAnimation\"\nimport { NativeAnimation } from \"../animation/NativeAnimation\"\nimport { NativeAnimationWrapper } from \"../animation/NativeAnimationWrapper\"\nimport { AnimationPlaybackControls, DOMKeyframesDefinition } from \"../animation/types\"\nimport { getValueTransition } from \"../animation/utils/get-value-transition\"\nimport { mapEasingToNativeEasing } from \"../animation/waapi/easing/map-easing\"\nimport { applyGeneratorOptions } from \"../animation/waapi/utils/apply-generator\"\nimport { cornerRadiusProps } from \"../utils/border-radius\"\nimport { ElementOrSelector, resolveElements } from \"../utils/resolve-elements\"\nimport type { ViewTransitionBuilder } from \"./index\"\nimport { ViewTransitionTarget, ViewTransitionTargetDefinition } from \"./types\"\nimport {\n assignViewTransitionNames,\n releaseViewTransitionNames,\n} from \"./utils/assign-names\"\nimport { chooseLayerType } from \"./utils/choose-layer-type\"\nimport { css } from \"./utils/css\"\nimport { getViewAnimationLayerInfo } from \"./utils/get-layer-info\"\nimport { getViewAnimations } from \"./utils/get-view-animations\"\nimport { hasTarget } from \"./utils/has-target\"\n\nconst definitionNames = [\"layout\", \"enter\", \"exit\", \"new\", \"old\"] as const\n\ntype CornerRadii = Record<(typeof cornerRadiusProps)[number], string>\n\n/**\n * Whether a computed border-radius is square (every component zero). Splitting\n * on whitespace handles two-value/elliptical radii like \"0px 20px\" - a leading\n * `parseFloat` alone would misread the non-zero vertical radius as square.\n */\nconst isSquareRadius = (radius: string) =>\n radius.split(\" \").every((value) => parseFloat(value) === 0)\n\n/**\n * The `ViewTransitionTarget` buckets driving each generated layer type, in\n * priority order - the inverse of `chooseLayerType`. The new view is driven by\n * `new`/`enter`, the old by `old`/`exit`. `group-children`/`image-pair` have no\n * bucket; they follow the default layout timing.\n */\nconst typeBuckets: Record = {\n group: [\"layout\"],\n new: [\"new\", \"enter\"],\n old: [\"old\", \"exit\"],\n}\n\n/**\n * Default \"absent\" origin for a single-value keyframe, by pseudo type, so e.g.\n * `enter({ scale: 1 })` grows in from 0.85 and `exit({ opacity: 0 })` fades\n * from 1. `enter` prefers the matching `exit` value over these (see below).\n */\nconst ORIGIN_DEFAULTS: Record> = {\n new: { opacity: 0, scale: 0.85 },\n old: { opacity: 1, scale: 1 },\n}\n\n/**\n * How much two box aspect ratios must differ before a morph is treated as\n * aspect-changing (and so worth cropping). Matches the projection engine's\n * `preserve-aspect` threshold, so small layout jitter doesn't trigger a crop.\n */\nconst ASPECT_TOLERANCE = 0.2\n\nexport function startViewAnimation(\n builder: ViewTransitionBuilder\n): Promise {\n const {\n update,\n targets,\n resolveDefs,\n cropOverride,\n pairs,\n classNames,\n flatGroups,\n options: defaultOptions,\n } = builder\n\n if (!document.startViewTransition) {\n // An async IIFE (not `new Promise(async …)`) so a throwing/rejecting\n // update rejects this promise rather than leaving it unsettled.\n return (async () => {\n await update()\n return new GroupAnimation([])\n })()\n }\n\n /**\n * Resolve any selector/Element targets to layer names, assigning a\n * `view-transition-name` to each element as we go. We run this before the\n * update (so the elements are captured in the old snapshot) and again\n * after it (for the new snapshot). An element present in both keeps the\n * same name and animates as a single `group` layer.\n */\n const nameRegistry = new Map()\n const assigned: Element[] = []\n /**\n * Elements we tagged with a `view-transition-class` (via `.class()`),\n * tracked separately from `assigned` so cleanup removes the class without\n * ever stripping an author's own inline `view-transition-name`.\n */\n const classed: Element[] = []\n /**\n * Elements we set a `view-transition-group` on (for nesting), tracked for\n * cleanup. `clipChildren` collects the names of nested parents that clip in\n * the live layout, so their `::view-transition-group-children` is clipped\n * through the transition - not just once the live DOM takes back over.\n */\n const grouped: Element[] = []\n const clipChildren = new Set()\n const layerTargets = new Map()\n const croppedNames = new Set()\n /**\n * Each layer's explicit `.crop(true | false)` override (by resolved name),\n * so `finalizeCrop` can let an author's choice win over the morph default.\n */\n const cropForName = new Map()\n /**\n * Each layer's stagger position (index + total) within its subject, per\n * snapshot. Resolving against the snapshot the layer belongs to keeps\n * stagger correct when `update()` replaces the matched elements, and lets\n * us skip a layer that's absent from a snapshot (e.g. an exited element\n * has no `new` pseudo-element).\n */\n const layerStagger = new Map<\n string,\n { old?: [number, number]; new?: [number, number] }\n >()\n /**\n * Names allocated for a paired subject in the old snapshot, replayed onto\n * its new-snapshot target so both ends share a layer and morph.\n */\n const pairNames = new Map()\n /**\n * The old (`from`) elements of each paired subject, so their names can be\n * transferred off before the new (`to`) elements inherit them.\n */\n const pairFrom = new Map()\n\n const resolveLayers = (phase: \"old\" | \"new\") => {\n targets.forEach((target, definition) => {\n const className = classNames.get(definition)\n /**\n * Nest each resolved layer under its DOM-ancestor layer by default\n * (`contain`), so an ancestor's clip/transform/opacity reach it\n * through the transition; `.group(false)` opts a subject out (`none`)\n * to stay flat and escape. Skipped for root / pre-named layers, which\n * aren't elements we resolve and style.\n */\n const group =\n definition === \"root\" || !resolveDefs.has(definition)\n ? undefined\n : flatGroups.has(definition)\n ? \"none\"\n : \"contain\"\n let names: string[]\n if (definition === \"root\" || !resolveDefs.has(definition)) {\n names = [definition as string]\n } else if (pairs.has(definition)) {\n /**\n * Paired morph: name the old target in the old snapshot, then\n * force the same name(s) onto the new target in the new one, so\n * two different elements morph as a single layer.\n */\n if (phase === \"old\") {\n pairFrom.set(\n definition,\n resolveElements(definition as ElementOrSelector)\n )\n names = assignViewTransitionNames(\n definition as ElementOrSelector,\n nameRegistry,\n assigned,\n undefined,\n className,\n classed,\n group,\n grouped,\n clipChildren\n )\n pairNames.set(definition, names)\n } else {\n /**\n * Transfer the name(s) off the `from` elements before the\n * `to` elements inherit them. A `from` that survives into\n * the new snapshot (e.g. hidden with `visibility: hidden`\n * rather than removed) would otherwise keep the name and\n * collide - \"duplicate view-transition-name\".\n */\n for (const el of pairFrom.get(definition) ?? []) {\n ;(el as HTMLElement).style?.removeProperty(\n \"view-transition-name\"\n )\n /**\n * Drop the old end from the registry too, so the new\n * end alone supplies this name's `new` crop radii - we\n * neither re-measure nor get ordered by a stale element.\n */\n nameRegistry.delete(el)\n }\n names = assignViewTransitionNames(\n pairs.get(definition) as ElementOrSelector,\n nameRegistry,\n assigned,\n pairNames.get(definition),\n className,\n classed,\n group,\n grouped,\n clipChildren\n )\n }\n } else {\n names = assignViewTransitionNames(\n definition as ElementOrSelector,\n nameRegistry,\n assigned,\n undefined,\n className,\n classed,\n group,\n grouped,\n clipChildren\n )\n }\n\n // Record any explicit `.crop(true | false)` per resolved name; the\n // crop set itself is computed later by `finalizeCrop` (it needs both\n // snapshots to know which morphs change aspect ratio).\n const override = cropOverride.get(definition)\n\n names.forEach((name, index) => {\n /**\n * If two subjects resolve to the same element, merge their\n * definitions so neither subject's animations are dropped.\n */\n const existing = layerTargets.get(name)\n layerTargets.set(\n name,\n existing && existing !== target\n ? { ...existing, ...target }\n : target\n )\n\n if (override !== undefined) cropForName.set(name, override)\n\n const stagger = layerStagger.get(name) ?? {}\n stagger[phase] = [index, names.length]\n layerStagger.set(name, stagger)\n })\n })\n }\n\n /**\n * The stagger index/total for a layer, resolved against the snapshot it\n * belongs to. Returns index -1 when the layer is absent from that snapshot\n * so the caller can skip a pseudo-element that doesn't exist.\n */\n const staggerPosition = (name: string, type: string) => {\n const stagger = layerStagger.get(name)\n const position =\n type === \"old\"\n ? stagger?.old\n : type === \"new\"\n ? stagger?.new\n : // group / group-children / image-pair persist across both.\n stagger?.new ?? stagger?.old\n return position ?? ([-1, 1] as const)\n }\n\n /**\n * Merge default + per-layer transition options for a generated layer and\n * resolve any stagger/delay function against this element's position. Used\n * by both the morph-retiming and crop corner-radius passes.\n */\n const resolveLayerTransition = (\n target: ViewTransitionTarget | undefined,\n type: string,\n transitionName: string,\n index: number,\n total: number\n ) => {\n const transition = mergeTransition(\n getValueTransition(defaultOptions, transitionName),\n getValueTransition(\n (layerOptions(target, type) ?? {}) as any,\n transitionName\n )\n )\n\n if (typeof transition.delay === \"function\") {\n transition.delay = transition.delay(index, total)\n }\n\n return transition\n }\n\n /**\n * Resolve a layer's group (`layout`) timing to plain WAAPI values: native\n * ms `delay`/`duration` and a baked `ease`. The single source of group\n * timing, shared by the generated-group retiming and the crop corner-radius\n * pass so the rounded clip animates on exactly the box's timing. It returns\n * no generator `type` (the WAAPI-only `NativeAnimation` rejects a string\n * type) nor `repeat`/`times` (which the group's `updateTiming` ignores), so\n * none of them can leak into the radius animation and desync it.\n */\n const resolveGroupTiming = (name: string) => {\n const [index, total] = staggerPosition(name, \"group\")\n const transition = resolveLayerTransition(\n layerTargets.get(name),\n \"group\",\n \"layout\",\n index === -1 ? 0 : index,\n total\n )\n transition.duration &&= secondsToMilliseconds(transition.duration)\n const { delay = 0, duration, ease } = applyGeneratorOptions(transition)\n return { delay: secondsToMilliseconds(delay), duration, ease }\n }\n\n /**\n * Each layer's measured box + corner radii per snapshot. The box lets\n * `finalizeCrop` tell whether a morph's aspect ratio changed (the only case\n * worth cropping); the radii let a cropped morph's group clip animate each\n * corner from the old element's radius to the new element's, keeping it\n * rounded where `overflow: clip` would otherwise square the corners.\n *\n * We never flatten the source for capture (a snapshot is a paint of the live\n * DOM, so squaring an element just for its capture would flash one real\n * square frame). For an aspect-changing morph `object-fit: cover` crops each\n * snapshot's own baked corners off-screen mid-morph, so the animated clip is\n * the only visible corner; a near-same-aspect forced crop (`.crop(true)`)\n * can't hide the outgoing snapshot's silhouette, but the endpoints coincide.\n */\n const cropMeasurements = new Map<\n string,\n {\n old?: { width: number; height: number; radii: CornerRadii }\n new?: { width: number; height: number; radii: CornerRadii }\n }\n >()\n\n const measureLayers = (phase: \"old\" | \"new\") =>\n nameRegistry.forEach((name, element) => {\n const el = element as HTMLElement\n const rect = el.getBoundingClientRect?.()\n if (rect && rect.height) {\n const style = getComputedStyle(el)\n const radii = {} as CornerRadii\n for (const corner of cornerRadiusProps) {\n radii[corner] = style[corner]\n }\n const entry = cropMeasurements.get(name) ?? {}\n entry[phase] = { width: rect.width, height: rect.height, radii }\n cropMeasurements.set(name, entry)\n }\n })\n\n /**\n * With both snapshots measured, settle which layers crop. The default crops\n * only a morph whose aspect ratio *changes* between snapshots - the one case\n * where `object-fit: cover` does real work. A same-aspect morph or a\n * fade-only layer is left uncropped: its corners scale naturally (no flash\n * from squaring, no `overflow: clip` eating its shadow) and a backdrop can't\n * be clipped to nothing. An explicit `.crop(true | false)` overrides either\n * way. Runs after both snapshots are measured, since aspect needs both.\n */\n const finalizeCrop = () => {\n croppedNames.clear()\n for (const name of layerStagger.keys()) {\n if (name === \"root\") continue\n // An explicit `.crop(true | false)` wins; otherwise crop a morph\n // whose aspect ratio changed.\n if (cropForName.get(name) ?? aspectChanged(name)) {\n croppedNames.add(name)\n }\n }\n }\n\n /**\n * Whether a layer is a morph whose box aspect ratio changed between\n * snapshots (beyond a small tolerance). Fade-only layers (one snapshot) are\n * never \"changed\".\n */\n const aspectChanged = (name: string) => {\n const box = cropMeasurements.get(name)\n if (!box?.old || !box?.new || !box.old.height || !box.new.height) {\n return false\n }\n return (\n Math.abs(\n box.old.width / box.old.height -\n box.new.width / box.new.height\n ) > ASPECT_TOLERANCE\n )\n }\n\n /**\n * Write the persistent view-transition CSS: suppress root capture when the\n * root has no animations of its own; force linear timing (baked into the\n * keyframes, so we can retime later via updateTiming); and clip +\n * object-fit: cover every cropped morph (the UA default overflows on\n * aspect-ratio change).\n *\n * `css.commit` replaces rather than appends, so we re-set the full rule set\n * each call - the crop rules are only known after `finalizeCrop` runs in the\n * update callback, so the second call writes them.\n */\n const commitViewCSS = () => {\n if (!hasTarget(\"root\", targets)) {\n css.set(\":root\", { \"view-transition-name\": \"none\" })\n }\n\n css.set(\n \"::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*)\",\n { \"animation-timing-function\": \"linear !important\" }\n )\n\n croppedNames.forEach((name) => {\n css.set(`::view-transition-group(${name})`, { overflow: \"clip\" })\n css.set(\n `::view-transition-old(${name}), ::view-transition-new(${name})`,\n { width: \"100%\", height: \"100%\", \"object-fit\": \"cover\" }\n )\n })\n\n /**\n * Clip the nested children of any layer that clips in the live layout,\n * so a wrapper crops its child for the whole morph (mirroring the DOM)\n * rather than only at the live-DOM handoff. No-op on browsers without\n * nested view-transition groups.\n */\n clipChildren.forEach((name) => {\n css.set(`::view-transition-group-children(${name})`, {\n overflow: \"clip\",\n })\n })\n\n css.commit() // Write\n }\n\n const cleanup = () => {\n releaseViewTransitionNames(assigned, classed, grouped)\n css.remove() // Write\n }\n\n const callback = async () => {\n await update()\n\n /**\n * Re-resolve so elements created by the update are named for the new\n * snapshot, then measure them. With both snapshots measured we can\n * settle the crop set (aspect-changing morphs + forced).\n */\n resolveLayers(\"new\")\n measureLayers(\"new\")\n finalizeCrop()\n\n /**\n * Re-commit the crop CSS unconditionally: `finalizeCrop` is computed\n * here (after both snapshots are measured), so the clip rules must be\n * (re)written to match the settled set.\n */\n commitViewCSS()\n }\n\n let transition: ViewTransition\n try {\n resolveLayers(\"old\")\n /**\n * Measure the old snapshot against the optimistic crop set (the new\n * snapshot doesn't exist yet, so aspect change can't be known here;\n * `finalizeCrop` settles it post-update).\n */\n measureLayers(\"old\")\n commitViewCSS()\n transition = document.startViewTransition(callback)\n } catch (error) {\n /**\n * The prelude writes inline names before the transition exists. If it\n * throws (e.g. startViewTransition rejects in a bad UA state), release\n * them so we neither leak DOM state nor stall the queue on a promise\n * that never settles - hand back a rejection it can advance past.\n */\n cleanup()\n return Promise.reject(error)\n }\n\n transition.finished.finally(cleanup)\n\n return new Promise((resolve, reject) => {\n transition.ready\n .then(() => {\n const generatedViewAnimations = getViewAnimations()\n\n const animations: AnimationPlaybackControls[] = []\n\n /**\n * Create animations for each of our explicitly-defined subjects.\n * `opacityAnimated` additionally tracks which `${name}:${type}`\n * we faded, so we can keep the UA `plus-lighter` blend only for a\n * genuine opacity crossfade (both sides fading) and drop it for a\n * slide/transform, where additive compositing would flash bright.\n */\n const explicitlyAnimated = new Set()\n const opacityAnimated = new Set()\n layerTargets.forEach((target, name) => {\n const stagger = layerStagger.get(name)\n /**\n * Presence: `enter` only fires for a pure newcomer (a new\n * view with no old), `exit` only for a pure leaver. A\n * survivor (both) gets neither - it just morphs.\n */\n const enterApplies = !!stagger?.new && !stagger?.old\n const exitApplies = !!stagger?.old && !stagger?.new\n\n for (const key of definitionNames) {\n if (!target[key]) continue\n if (key === \"enter\" && !enterApplies) continue\n if (key === \"exit\" && !exitApplies) continue\n\n const type = chooseLayerType(\n key as keyof ViewTransitionTarget\n )\n const [index, total] = staggerPosition(name, type)\n // Skip a layer absent from its snapshot.\n if (index === -1) continue\n\n const { keyframes, options } =\n target[key as keyof ViewTransitionTarget]!\n\n for (let [valueName, valueKeyframes] of Object.entries(\n keyframes\n )) {\n // Skip only missing values - `0` (e.g. opacity: 0)\n // is valid and must reach the from-value inference.\n if (valueKeyframes == null) continue\n\n /**\n * The view path hands keyframes straight to WAAPI,\n * so Motion's `x`/`y` shorthands (compiled to\n * `transform` only via the value pipeline) have no\n * effect. Warn and skip - use `transform`/`translate`.\n */\n if (valueName === \"x\" || valueName === \"y\") {\n warnOnce(\n false,\n `animateView() animates view-transition layers with CSS properties; the \"${valueName}\" shorthand has no effect - use transform, e.g. { transform: \"translateX(40px)\" }.`\n )\n continue\n }\n\n /**\n * enter/exit win over new/old on a shared property -\n * skip it here when the gated bucket also defines it.\n */\n if (\n key === \"new\" &&\n enterApplies &&\n target.enter?.keyframes[\n valueName as keyof DOMKeyframesDefinition\n ] != null\n ) {\n continue\n }\n if (\n key === \"old\" &&\n exitApplies &&\n target.exit?.keyframes[\n valueName as keyof DOMKeyframesDefinition\n ] != null\n ) {\n continue\n }\n\n const valueOptions = mergeTransition(\n getValueTransition(\n defaultOptions as any,\n valueName\n ),\n getValueTransition(options as any, valueName)\n )\n\n /**\n * Infer an origin for a single-value keyframe. An\n * `enter` mirrors the matching `exit` value (a\n * defined exit reverses into the enter for free);\n * otherwise the per-type default (opacity 0/1, scale\n * 0.85). No default -> left as-is (animates from the\n * live value).\n *\n * `new`/`old` fire for survivors too, where only the\n * opacity crossfade default applies - a transform\n * default like scale 0.85 would pop a persisting\n * element, so gate it on the layer actually\n * entering/leaving.\n */\n if (!Array.isArray(valueKeyframes)) {\n const exitValue =\n key === \"enter\"\n ? target.exit?.keyframes[\n valueName as keyof DOMKeyframesDefinition\n ]\n : undefined\n const allowDefault =\n valueName === \"opacity\" ||\n (type === \"new\" ? enterApplies : exitApplies)\n const from =\n exitValue != null\n ? Array.isArray(exitValue)\n ? exitValue[exitValue.length - 1]\n : exitValue\n : allowDefault\n ? ORIGIN_DEFAULTS[type]?.[valueName]\n : undefined\n if (from !== undefined) {\n valueKeyframes = [from, valueKeyframes]\n }\n }\n\n /**\n * Resolve stagger function if provided, per element\n * across this subject's resolved layers.\n */\n if (typeof valueOptions.delay === \"function\") {\n valueOptions.delay = valueOptions.delay(\n index,\n total\n )\n }\n\n valueOptions.duration &&= secondsToMilliseconds(\n valueOptions.duration\n )\n\n valueOptions.delay &&= secondsToMilliseconds(\n valueOptions.delay\n )\n\n animations.push(\n new NativeAnimation({\n ...valueOptions,\n element: document.documentElement,\n name: valueName,\n pseudoElement: `::view-transition-${type}(${name})`,\n keyframes: valueKeyframes,\n })\n )\n explicitlyAnimated.add(`${name}:${type}`)\n if (valueName === \"opacity\") {\n opacityAnimated.add(`${name}:${type}`)\n }\n }\n }\n })\n\n /**\n * Handle browser generated animations\n */\n for (const animation of generatedViewAnimations) {\n if (animation.playState === \"finished\") continue\n\n const { effect } = animation\n if (!effect || !(effect instanceof KeyframeEffect)) continue\n\n const { pseudoElement } = effect\n if (!pseudoElement) continue\n\n const name = getViewAnimationLayerInfo(pseudoElement)\n if (!name) continue\n\n const targetDefinition = layerTargets.get(name.layer)\n\n /**\n * We built our own animation for this layer, so drop the\n * browser-generated fade we're replacing. The UA\n * `plus-lighter` blend is a *separate* generated animation on\n * the same pseudo (it sets `mix-blend-mode` in its keyframes):\n * keep it *only* for a true opacity crossfade - both sides\n * fading - so a symmetric crossfade composites without\n * darkening, but a slide/transform (where both layers stay\n * opaque and overlap) doesn't flash bright from the addition.\n */\n if (explicitlyAnimated.has(`${name.layer}:${name.type}`)) {\n const isCrossfade =\n opacityAnimated.has(`${name.layer}:new`) &&\n opacityAnimated.has(`${name.layer}:old`)\n if (\n isCrossfade &&\n effect\n .getKeyframes()\n .some((keyframe) => keyframe.mixBlendMode)\n ) {\n animations.push(new NativeAnimationWrapper(animation))\n } else {\n animation.cancel()\n }\n continue\n }\n\n /**\n * Drop the orphaned half of the default crossfade. The UA\n * fades old out and new in as a *pair*; if the opposing half\n * was explicitly overridden with something other than an\n * opacity fade (a clip or transform reveal), this side's\n * default opacity fade has no partner - left to run it would\n * dissolve what should be a static backdrop (e.g.\n * `.new({ clipPath })` should reveal over a still old view,\n * not fade the old out around the growing clip). Cancel it -\n * and its `plus-lighter` sibling on the same pseudo, which\n * would otherwise flash bright where the two opaque layers\n * overlap. A genuine crossfade (the opposing side also fading\n * opacity) keeps both halves and is handled above.\n */\n const opposite =\n name.type === \"old\"\n ? \"new\"\n : name.type === \"new\"\n ? \"old\"\n : undefined\n if (\n opposite &&\n explicitlyAnimated.has(\n `${name.layer}:${opposite}`\n ) &&\n !opacityAnimated.has(`${name.layer}:${opposite}`)\n ) {\n animation.cancel()\n continue\n }\n\n /**\n * Otherwise retime the browser-generated animation to\n * Motion's timing. This auto-enables the layout (group)\n * morph for any resolved/named target, and applies the\n * default timing to old/new layers we haven't explicitly\n * overridden.\n *\n * group + group-children both follow the layout timing so\n * the nesting container stays in sync with the morph.\n */\n /**\n * A survivor's old + new are the two halves of one\n * `plus-lighter` crossfade. They must share identical timing\n * (so their opacities stay mirrored and sum to 1 - else the\n * additive blend flashes bright wherever both are partly\n * visible) and fade linearly (the bounce belongs on the\n * group's geometry, not the opacity). So time them as the\n * group, rather than via their own - potentially staggered,\n * or enter/exit-derived - old/new options.\n */\n const stagger = layerStagger.get(name.layer)\n const isMorphCrossfade =\n (name.type === \"old\" || name.type === \"new\") &&\n !!stagger?.old &&\n !!stagger?.new\n\n let timing: {\n delay: number\n duration?: number\n easing: string\n }\n if (name.type.startsWith(\"group\")) {\n // group + group-children follow the resolved group\n // timing - the single source shared with the crop\n // corner-radius pass below.\n const { delay, duration, ease } = resolveGroupTiming(\n name.layer\n )\n timing = {\n delay,\n duration,\n easing: mapEasingToNativeEasing(\n ease,\n duration!\n ) as string,\n }\n } else {\n const timingType = isMorphCrossfade ? \"group\" : name.type\n const [index, total] = staggerPosition(\n name.layer,\n timingType\n )\n const transitionName =\n timingType === \"group\" ? \"layout\" : \"\"\n let animationTransition = resolveLayerTransition(\n targetDefinition,\n timingType,\n transitionName,\n index === -1 ? 0 : index,\n total\n )\n\n /**\n * The crossfade should resolve at the spring's\n * *perceptual* (visual) duration - the geometry can keep\n * bouncing, but the opacity shouldn't drag through the\n * settle. So capture `visualDuration` before\n * `applyGeneratorOptions` replaces it with the full\n * overshoot duration, and use it for the fade.\n */\n const visualDuration = animationTransition.visualDuration\n\n animationTransition.duration &&= secondsToMilliseconds(\n animationTransition.duration\n )\n\n animationTransition =\n applyGeneratorOptions(animationTransition)\n\n timing = {\n delay: secondsToMilliseconds(\n animationTransition.delay ?? 0\n ),\n duration:\n isMorphCrossfade && visualDuration !== undefined\n ? secondsToMilliseconds(visualDuration)\n : animationTransition.duration,\n easing: isMorphCrossfade\n ? \"linear\"\n : (mapEasingToNativeEasing(\n animationTransition.ease,\n animationTransition.duration!\n ) as string),\n }\n }\n\n effect.updateTiming(timing)\n\n animations.push(new NativeAnimationWrapper(animation))\n }\n\n /**\n * Round each cropped layer's clip. Its `::view-transition-group`\n * has `overflow: clip`, which would otherwise square the corners\n * mid-morph; animate each corner from the old element's radius to\n * the new element's so the crop stays rounded. Timed as the group\n * (`layout`) so the radius tracks the morphing box.\n */\n cropMeasurements.forEach((entry, name) => {\n if (!croppedNames.has(name)) return\n\n // Reuse the group's resolved timing - native ms delay/\n // duration + a baked ease, with no generator `type` or\n // repeat/times to leak into (or throw inside) NativeAnimation.\n const { delay, duration, ease } = resolveGroupTiming(name)\n\n for (const corner of cornerRadiusProps) {\n // `||` (not `??`) so an empty measurement falls back to\n // the other snapshot rather than an invalid keyframe.\n const from =\n entry.old?.radii[corner] ||\n entry.new?.radii[corner] ||\n \"0px\"\n const to =\n entry.new?.radii[corner] ||\n entry.old?.radii[corner] ||\n \"0px\"\n // Nothing to round if the corner is square at both ends.\n if (isSquareRadius(from) && isSquareRadius(to)) continue\n\n animations.push(\n new NativeAnimation({\n element: document.documentElement,\n name: corner,\n pseudoElement: `::view-transition-group(${name})`,\n keyframes: [from, to],\n delay,\n duration,\n ease,\n })\n )\n }\n })\n\n resolve(new GroupAnimation(animations))\n })\n .catch(() =>\n /**\n * `ready` rejects when the transition is skipped - no visual\n * change, or superseded by an interrupting transition. The DOM\n * update still applied, so settle with no animations rather than\n * surfacing it as an error to an awaiting caller. A genuine\n * failure in `update()` rejects `updateCallbackDone` (already\n * settled by now), so propagate that instead.\n */\n transition.updateCallbackDone.then(\n () => resolve(new GroupAnimation([])),\n reject\n )\n )\n })\n}\n\n/**\n * The options that should time a given generated layer type, so a retimed\n * group/old/new picks up any per-target transition the user provided. Checks\n * the type's buckets in priority order (e.g. `new` before `enter`).\n */\nfunction layerOptions(target: ViewTransitionTarget | undefined, type: string) {\n for (const bucket of typeBuckets[type] ?? []) {\n const options = target?.[bucket]?.options\n if (options) return options\n }\n}\n\n/**\n * Merge a base transition (e.g. the default `options`) with a per-layer/value\n * override. An explicit `duration` on the override must win over an inherited\n * generator's own timing: a spring prefers `visualDuration`, and\n * `spring.applyToOptions` overwrites `duration` with the computed settle time -\n * so without this the override is silently discarded. Dropping the inherited\n * `type`/`visualDuration` makes the layer a plain tween of that duration, unless\n * it asked for its own generator `type`/`visualDuration`.\n */\nfunction mergeTransition(base: any, override: any) {\n const merged = { ...base, ...override }\n\n if (override.duration !== undefined) {\n if (override.visualDuration === undefined) delete merged.visualDuration\n if (override.type === undefined) delete merged.type\n }\n\n return merged\n}\n"],"names":[],"mappings":"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"}