@texuli/deck 0.0.0-stage → 0.5.0

package/dist/model/migrate.js

@@ -0,0 +1,453 @@
+/**
+ * `migrateDeck`: convert an earlier deck to model v2 (model-v2 §3.10). The
+ * input shape is detected, not read from a version number:
+ *
+ * - **v2** (`formatVersion` present): returned unchanged.
+ * - **Texuli v1** (`meta` + `slides[].blocks`, optional `masters` and
+ *   `settings`): every slide becomes a lossless free slide with its master;
+ *   `settings` moves to `style` and `navigation`, `startIndex` to a start id.
+ * - **Texuli grammar tree** (`layout-deck` with `deck-slide` or legacy
+ *   `layout-card` children, or a `slides[]` grammar): block nodes become
+ *   blocks, `charts-*` nodes chart blocks, other catalog nodes component items.
+ * - **Protoyard** (`style` + `slides` with `layout`, no `meta`): a title is
+ *   derived, `paletteSeed` becomes a seed theme, ChartSpec becomes a chart
+ *   block body, unknown background slugs become `solid-color`.
+ *
+ * The result is not validated (run `parseDeck`); every conversion that is a
+ * judgement call is reported as a `migrated` warning. Idempotent, pure, and
+ * it never throws. Lifting a master to a catalog layout is a lint
+ * suggestion, never done here.
+ */
+import { createDiagnostic } from "../schema/index.js";
+import { isDeckBackgroundPreset } from "./backgrounds/schema.js";
+import { DECK_MODEL_LIMITS } from "./deck.js";
+import { MEDIA_SRC_PATTERN } from "./shared.js";
+import { slideSteps } from "./steps/slide-steps.js";
+export const DECK_SOURCES = ['v2', 'texuli-v1', 'texuli-grammar', 'protoyard', 'unknown'];
+function isBag(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+const MEDIA_SRC = new RegExp(MEDIA_SRC_PATTERN, 'u');
+/** The chart kinds with inline `series`/`cells`/`points` in the Texuli chart block. */
+const INLINE_CHART_KINDS = [
+    'line',
+    'area',
+    'bar',
+    'stacked-bar',
+    'combo',
+    'heatmap',
+    'scatter',
+    'bubble',
+];
+const GRAMMAR_ROOT = 'layout-deck';
+const GRAMMAR_SLIDE = 'deck-slide';
+const GRAMMAR_CARD = 'layout-card';
+const DEFAULT_TITLE = 'Untitled deck';
+/** Which earlier shape `input` has (see the module comment). */
+export function detectDeckShape(input) {
+    if (!isBag(input))
+        return 'unknown';
+    if (Object.hasOwn(input, 'formatVersion'))
+        return 'v2';
+    if (input.id === GRAMMAR_ROOT)
+        return 'texuli-grammar';
+    if (!Array.isArray(input.slides))
+        return 'unknown';
+    if (isBag(input.meta))
+        return 'texuli-v1';
+    const slides = input.slides;
+    if (isBag(input.style) ||
+        slides.some((slide) => isBag(slide) && typeof slide.layout === 'string')) {
+        return 'protoyard';
+    }
+    return 'unknown';
+}
+class Notes {
+    issues = [];
+    warn(message, path = [], fix) {
+        if (this.issues.length >= 200)
+            return;
+        this.issues.push(createDiagnostic('migrated', message, path, {
+            severity: 'warning',
+            ...(fix === undefined ? {} : { fix }),
+        }));
+    }
+}
+function clip(value, max) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    const points = Array.from(trimmed);
+    return points.length > max ? points.slice(0, max).join('') : trimmed;
+}
+function assign(target, key, value) {
+    if (value !== undefined)
+        target[key] = value;
+}
+// ---------------------------------------------------------------------------
+// Texuli v1
+/**
+ * A catalog theme without a mode becomes the string shorthand, so every
+ * authoring form (JSON, Markdown `theme:`) round-trips it unchanged.
+ */
+function shorthandTheme(theme) {
+    if (theme === null || typeof theme !== 'object' || Array.isArray(theme))
+        return theme;
+    const ref = theme;
+    const keys = Object.keys(ref);
+    if (ref.kind === 'catalog' &&
+        typeof ref.id === 'string' &&
+        keys.every((key) => key === 'kind' || key === 'id')) {
+        return ref.id;
+    }
+    return theme;
+}
+const V1_SLIDE_KEYS = ['id', 'title', 'notes', 'master', 'themeRef', 'transition', 'blocks'];
+function fromTexuliV1(input, notes) {
+    const meta = isBag(input.meta) ? input.meta : {};
+    const settings = isBag(input.settings) ? input.settings : {};
+    const slidesIn = Array.isArray(input.slides) ? input.slides : [];
+    const outMeta = {};
+    assign(outMeta, 'title', meta.title);
+    assign(outMeta, 'description', meta.description);
+    assign(outMeta, 'locale', meta.locale);
+    const style = {};
+    assign(style, 'aspect', meta.aspect);
+    assign(style, 'theme', shorthandTheme(meta.themeRef));
+    if (settings.showProgress === false)
+        style.progress = 'none';
+    if (settings.defaultTransition !== undefined && settings.defaultTransition !== 'fade') {
+        style.transition = settings.defaultTransition;
+    }
+    const navigation = {};
+    const startIndex = settings.startIndex;
+    if (typeof startIndex === 'number' && Number.isInteger(startIndex) && startIndex > 0) {
+        const target = slidesIn[startIndex];
+        if (isBag(target) && typeof target.id === 'string')
+            navigation.start = target.id;
+        else
+            notes.warn(`settings.startIndex ${startIndex} names no slide; the deck starts at the first.`, ['navigation']);
+    }
+    if (settings.loop === true)
+        navigation.loop = true;
+    const slides = slidesIn.map((slide, i) => {
+        if (!isBag(slide))
+            return slide;
+        const path = ['slides', i];
+        const out = {};
+        assign(out, 'id', slide.id);
+        assign(out, 'title', slide.title);
+        assign(out, 'notes', slide.notes);
+        assign(out, 'theme', shorthandTheme(slide.themeRef));
+        assign(out, 'transition', slide.transition);
+        out.layout = 'free';
+        assign(out, 'master', slide.master);
+        // An empty v1 slide stays empty: v2 free slides may have no blocks, and
+        // the stage already shows the slide title.
+        const blocks = Array.isArray(slide.blocks) ? slide.blocks : [];
+        out.blocks = blocks;
+        const dropped = Object.keys(slide).filter((key) => !V1_SLIDE_KEYS.includes(key));
+        if (dropped.length > 0) {
+            notes.warn(`Dropped keys v1 ignored: ${dropped.slice(0, 8).join(', ')}.`, path);
+        }
+        const steps = slideSteps(out);
+        const renumbered = steps.steps.some((step) => step.fragments.some((fragment) => fragment.authored > 0 && fragment.authored !== step.index));
+        if (renumbered) {
+            notes.warn('Steps are renumbered densely in v2: gaps between authored steps no longer cost an empty click.', path);
+        }
+        return out;
+    });
+    const out = { formatVersion: 2, meta: outMeta };
+    if (Object.keys(style).length > 0)
+        out.style = style;
+    if (Object.keys(navigation).length > 0)
+        out.navigation = navigation;
+    out.slides = slides;
+    if (Array.isArray(input.masters) && input.masters.length > 0) {
+        notes.warn('The `masters` declaration is dropped; each free slide keeps its own `master`.', [
+            'slides',
+        ]);
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Texuli grammar trees
+function chartFromNode(id, props) {
+    const kind = id === 'charts-cartesian' ? props.kind : id.slice('charts-'.length);
+    const titleKey = props.title === undefined ? 'label' : 'title';
+    const { [titleKey]: title, description, kind: _kind, ...rest } = props;
+    const block = { type: 'chart', kind, title, description };
+    if (INLINE_CHART_KINDS.includes(kind)) {
+        for (const key of ['series', 'cells', 'points'])
+            assign(block, key, props[key]);
+    }
+    else
+        block.props = rest;
+    return block;
+}
+function itemFromNode(node, path, notes) {
+    if (!isBag(node))
+        return node;
+    const id = typeof node.id === 'string' ? node.id : '';
+    const props = isBag(node.props) ? node.props : {};
+    if (Object.hasOwn(props, 'block'))
+        return props.block;
+    if (id.startsWith('charts-'))
+        return chartFromNode(id, props);
+    notes.warn(`The catalog node "${id.slice(0, 64)}" became a component item.`, path);
+    return { type: 'component', component: id, props };
+}
+function slideFromGrammar(props, children, id, path, notes) {
+    const out = {};
+    assign(out, 'id', id);
+    assign(out, 'title', props.title);
+    assign(out, 'notes', props.notes);
+    assign(out, 'master', props.master);
+    assign(out, 'themeRef', props.themeRef);
+    assign(out, 'transition', props.transition);
+    const nodes = Array.isArray(children) ? children : [];
+    out.blocks = nodes.map((node, b) => itemFromNode(node, [...path, 'blocks', b], notes));
+    return out;
+}
+function fromGrammar(input, notes) {
+    const props = isBag(input.props) ? input.props : {};
+    const slides = [];
+    if (Array.isArray(props.slides)) {
+        props.slides.forEach((slide, i) => {
+            const value = isBag(slide) ? slide : {};
+            slides.push(slideFromGrammar(value, value.children, value.id, ['slides', i], notes));
+        });
+    }
+    else if (Array.isArray(input.children)) {
+        input.children.forEach((node, i) => {
+            const value = isBag(node) ? node : {};
+            const nodeProps = isBag(value.props) ? value.props : {};
+            const path = ['slides', i];
+            if (value.id === GRAMMAR_CARD) {
+                const card = slideFromGrammar({ title: nodeProps.title }, value.children, `slide-${i + 1}`, path, notes);
+                slides.push(card);
+            }
+            else {
+                if (value.id !== GRAMMAR_SLIDE) {
+                    notes.warn(`Expected a ${GRAMMAR_SLIDE} node; read it as one.`, path);
+                }
+                slides.push(slideFromGrammar(nodeProps, value.children, nodeProps.slideId, path, notes));
+            }
+        });
+    }
+    const v1 = {
+        meta: {
+            title: props.title,
+            ...(props.description === undefined ? {} : { description: props.description }),
+            ...(props.locale === undefined ? {} : { locale: props.locale }),
+            ...(props.aspect === undefined ? {} : { aspect: props.aspect }),
+            ...(props.themeRef === undefined ? {} : { themeRef: props.themeRef }),
+        },
+        slides,
+    };
+    assign(v1, 'masters', props.masters);
+    assign(v1, 'settings', props.settings);
+    return fromTexuliV1(v1, notes);
+}
+// ---------------------------------------------------------------------------
+// Protoyard
+const PART_WHOLE = ['pie', 'donut'];
+const STEP_KEYS = ['step', 'fragment', 'reveal', 'tone'];
+/** Protoyard's ChartSpec (`kind`, `labels`, `series[{label, values}]`) as a chart block body. */
+function chartBody(spec, path, notes) {
+    const labels = Array.isArray(spec.labels) ? spec.labels : [];
+    const series = Array.isArray(spec.series) ? spec.series : [];
+    const out = { kind: spec.kind, title: spec.title };
+    if (typeof spec.description === 'string' && spec.description.trim() !== '') {
+        out.description = spec.description;
+    }
+    else {
+        out.description = spec.title;
+        notes.warn('The chart had no description; its title is used (write a real one).', [
+            ...path,
+            'description',
+        ]);
+    }
+    const values = (entry) => isBag(entry) && Array.isArray(entry.values) ? entry.values : [];
+    /** A series entry's step marker (`step`, `fragment`, `reveal`, `tone`), kept as authored. */
+    const marker = (entry) => {
+        const out = {};
+        if (isBag(entry))
+            for (const key of STEP_KEYS)
+                assign(out, key, entry[key]);
+        return out;
+    };
+    if (PART_WHOLE.includes(spec.kind) || spec.kind === 'funnel') {
+        const first = values(series[0]);
+        const data = labels.map((label, j) => ({
+            id: `item-${j + 1}`,
+            label,
+            value: typeof first[j] === 'number' ? first[j] : 0,
+        }));
+        out.props = spec.kind === 'funnel' ? { steps: data } : { data };
+        // One data list: a marker on the first series moves to the chart itself.
+        const firstMarker = marker(series[0]);
+        if (Object.keys(firstMarker).length > 0) {
+            if (spec.step === undefined)
+                Object.assign(out, firstMarker);
+            else
+                notes.warn('The first series step marker was dropped; the chart has its own.', [
+                    ...path,
+                    'series',
+                    0,
+                ]);
+        }
+    }
+    else {
+        out.series = series.map((entry, s) => ({
+            id: `series-${s + 1}`,
+            label: isBag(entry) ? entry.label : undefined,
+            points: labels.map((x, j) => {
+                const y = values(entry)[j];
+                return { x, y: typeof y === 'number' ? y : null };
+            }),
+            ...marker(entry),
+        }));
+    }
+    if ((spec.unit !== undefined && spec.unit !== 'number') || spec.currency !== undefined) {
+        notes.warn('The chart `unit`/`currency` was dropped; set a chart format in props.', path);
+    }
+    for (const key of STEP_KEYS)
+        assign(out, key, spec[key]);
+    notes.warn('The Protoyard ChartSpec became a Texuli chart block body.', path);
+    return out;
+}
+function isChartSpec(value) {
+    return (isBag(value) &&
+        Array.isArray(value.labels) &&
+        Array.isArray(value.series) &&
+        value.series.every((entry) => isBag(entry) && Array.isArray(entry.values)));
+}
+function background(value, path, notes) {
+    if (typeof value !== 'string' || isDeckBackgroundPreset(value))
+        return value;
+    notes.warn(`Unknown background "${value.slice(0, 64)}" became "solid-color".`, path, 'Pick one of the 13 background presets or a spec.');
+    return 'solid-color';
+}
+function deriveTitle(input, slides) {
+    const outline = isBag(input.outline) ? input.outline : {};
+    const fromOutline = clip(outline.title, DECK_MODEL_LIMITS.titleLength);
+    if (fromOutline)
+        return { title: fromOutline, derived: 'outline.title' };
+    for (const slide of slides) {
+        if (isBag(slide) && slide.layout === 'title-hero' && isBag(slide.props)) {
+            const title = clip(slide.props.title, DECK_MODEL_LIMITS.titleLength);
+            if (title)
+                return { title, derived: 'the title-hero slide' };
+        }
+    }
+    for (const slide of slides) {
+        const title = isBag(slide) ? clip(slide.title, DECK_MODEL_LIMITS.titleLength) : undefined;
+        if (title)
+            return { title, derived: 'the first slide title' };
+    }
+    return { title: DEFAULT_TITLE, derived: 'a placeholder' };
+}
+function fromProtoyard(input, notes) {
+    const slidesIn = Array.isArray(input.slides) ? input.slides : [];
+    const { title, derived } = deriveTitle(input, slidesIn);
+    notes.warn(`meta.title was derived from ${derived}.`, ['meta', 'title']);
+    const styleIn = isBag(input.style) ? input.style : {};
+    const style = {};
+    for (const [key, value] of Object.entries(styleIn)) {
+        if (key === 'paletteSeed')
+            continue;
+        if (key === 'background')
+            style.background = background(value, ['style', 'background'], notes);
+        else if (key === 'logo') {
+            if (typeof value === 'string' && value.length <= 512 && MEDIA_SRC.test(value))
+                style.logo = value;
+            else
+                notes.warn('The logo is not a supported media source and was dropped.', ['style', 'logo']);
+        }
+        else
+            style[key] = value;
+    }
+    if (styleIn.paletteSeed !== undefined) {
+        if (style.theme === undefined)
+            style.theme = { kind: 'seed', seed: styleIn.paletteSeed };
+        else
+            notes.warn('`paletteSeed` was dropped: the named theme wins.', ['style', 'theme']);
+    }
+    const slides = slidesIn.map((slide, i) => {
+        if (!isBag(slide))
+            return slide;
+        const path = ['slides', i];
+        const out = { ...slide };
+        if (slide.background !== undefined) {
+            out.background = background(slide.background, [...path, 'background'], notes);
+        }
+        if (slide.layout === 'chart' && isBag(slide.props) && isChartSpec(slide.props.spec)) {
+            out.props = {
+                ...slide.props,
+                spec: chartBody(slide.props.spec, [...path, 'props', 'spec'], notes),
+            };
+        }
+        return out;
+    });
+    const out = { formatVersion: 2, meta: { title } };
+    if (Object.keys(style).length > 0)
+        out.style = style;
+    for (const [key, value] of Object.entries(input)) {
+        if (key !== 'style' && key !== 'slides')
+            out[key] = value;
+    }
+    out.slides = slides;
+    return out;
+}
+// ---------------------------------------------------------------------------
+const LABELS = Object.freeze({
+    v2: 'a v2 deck',
+    'texuli-v1': 'a Texuli v1 deck',
+    'texuli-grammar': 'a Texuli grammar tree',
+    protoyard: 'a Protoyard deck',
+    unknown: 'an unknown shape',
+});
+/** Convert `input` to model v2; see the module comment. Never throws. */
+export function migrateDeck(input) {
+    const notes = new Notes();
+    let from = 'unknown';
+    try {
+        from = detectDeckShape(input);
+        if (from === 'v2')
+            return { deck: input, from, issues: [] };
+        if (from === 'unknown') {
+            return {
+                deck: input,
+                from,
+                issues: [
+                    createDiagnostic('invalid-deck', 'Not a recognized deck: expected a v2 deck, a Texuli v1 deck, a layout-deck tree or a Protoyard deck.', [], { fix: 'Start from {"formatVersion": 2, "meta": {"title": "…"}, "slides": […]}.' }),
+                ],
+            };
+        }
+        const source = input;
+        const deck = from === 'texuli-v1'
+            ? fromTexuliV1(source, notes)
+            : from === 'texuli-grammar'
+                ? fromGrammar(source, notes)
+                : fromProtoyard(source, notes);
+        notes.issues.unshift(createDiagnostic('migrated', `Converted from ${LABELS[from]} to model v2.`, [], {
+            severity: 'warning',
+            fix: 'Save the converted deck so it loads without migration.',
+        }));
+        return { deck, from, issues: notes.issues };
+    }
+    catch {
+        return {
+            deck: input,
+            from,
+            issues: [
+                createDiagnostic('invalid-input', 'The deck could not be read as plain data.', [], {
+                    fix: 'Pass JSON data (loadUntrustedDeck makes a safe copy).',
+                }),
+            ],
+        };
+    }
+}

package/dist/model/motion/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Slide transitions and fragment motion of deck model v2 (model-v2 §3.1,
+ * §3.2): precedence slide → deck → `fade`, the motion ceiling and the
+ * reduced-motion floor, capped at `MAX_MOTION_MS`.
+ */
+export { DEFAULT_MOTION, DEFAULT_TRANSITION, type DeckSlideTransition, effectiveMotion, FRAGMENT_MS, type FragmentMotionOptions, type FragmentMotionReason, isDeckTransition, isMotionLevel, MAX_MOTION_MS, MOTION_LEVELS, type MotionLevel, type MotionOptions, REDUCED_FADE_MS, type ResolvedFragmentMotion, type ResolvedTransition, resolveDeckTransitions, resolveFragmentMotion, resolveSlideTransition, type SlideTransitionInput, SUBTLE_SCALE, TRANSITION_MS, type TransitionDeck, type TransitionReason, type TransitionSlide, } from './transition.js';

package/dist/model/motion/index.js

@@ -0,0 +1,6 @@
+/**
+ * Slide transitions and fragment motion of deck model v2 (model-v2 §3.1,
+ * §3.2): precedence slide → deck → `fade`, the motion ceiling and the
+ * reduced-motion floor, capped at `MAX_MOTION_MS`.
+ */
+export { DEFAULT_MOTION, DEFAULT_TRANSITION, effectiveMotion, FRAGMENT_MS, isDeckTransition, isMotionLevel, MAX_MOTION_MS, MOTION_LEVELS, REDUCED_FADE_MS, resolveDeckTransitions, resolveFragmentMotion, resolveSlideTransition, SUBTLE_SCALE, TRANSITION_MS, } from "./transition.js";

package/dist/model/motion/transition.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Slide transitions and fragment motion under a motion level (ported from
+ * Protoyard's `motion/transition.ts`, plus v1's `fade-up` transition).
+ *
+ * - The deck's `style.motion` (`full` | `subtle` | `none`) is the ceiling;
+ *   an explicit `motion` option replaces it.
+ * - The viewer's reduced-motion preference only lowers it, never raises it:
+ *   with it, every transition is `none` or a short fade, and moving
+ *   fragments become plain fades.
+ * - Durations are opacity and transform only and never exceed
+ *   `MAX_MOTION_MS`.
+ *
+ * Inputs are structural plain objects; unknown values fall through to the
+ * next source (slide → deck → `fade`) instead of throwing.
+ */
+import { type DeckTransition, type FragmentEffect } from '../shared.js';
+export declare const MOTION_LEVELS: readonly ["full", "subtle", "none"];
+export type MotionLevel = (typeof MOTION_LEVELS)[number];
+export declare const MAX_MOTION_MS = 400;
+/** A reduced-motion fade: short enough to read as a cut, long enough not to flash. */
+export declare const REDUCED_FADE_MS = 150;
+/** Subtle motion runs at this share of the full duration. */
+export declare const SUBTLE_SCALE = 0.6;
+/** A fragment's full-motion duration. */
+export declare const FRAGMENT_MS = 300;
+export declare const DEFAULT_TRANSITION: DeckTransition;
+export declare const DEFAULT_MOTION: MotionLevel;
+/** Full-motion transition durations, in milliseconds. */
+export declare const TRANSITION_MS: Readonly<Record<DeckTransition, number>>;
+/** The slide fields the resolver reads. */
+export interface TransitionSlide {
+    id?: unknown;
+    transition?: unknown;
+}
+/** The deck fields the resolver reads. */
+export interface TransitionDeck {
+    style?: {
+        transition?: unknown;
+        motion?: unknown;
+    } | null;
+    slides?: readonly TransitionSlide[];
+}
+export interface MotionOptions {
+    /** The motion ceiling; defaults to `deck.style.motion`, then `full`. */
+    motion?: MotionLevel;
+    /** The viewer's preference (`prefers-reduced-motion` or a host toggle). */
+    reducedMotion?: boolean;
+}
+export interface SlideTransitionInput extends MotionOptions {
+    slide?: TransitionSlide | null;
+    deck?: TransitionDeck | null;
+}
+export type TransitionReason = 'motion-none' | 'reduced-motion' | 'subtle' | 'slide-override' | 'deck-default' | 'engine-default';
+export interface ResolvedTransition {
+    /** The transition to play. */
+    name: DeckTransition;
+    durationMs: number;
+    /** What the author asked for before the motion level applied. */
+    requested: DeckTransition;
+    /** The level after the viewer's preference was applied. */
+    motion: MotionLevel;
+    /** Why the result is what it is, for DevTools and tests. */
+    reason: TransitionReason;
+}
+export declare function isDeckTransition(value: unknown): value is DeckTransition;
+export declare function isMotionLevel(value: unknown): value is MotionLevel;
+/** The requested level (option, then deck style, then `full`), lowered by reduced motion. */
+export declare function effectiveMotion(options?: MotionOptions & {
+    deck?: TransitionDeck | null;
+}): MotionLevel;
+/** The transition into `slide`: slide override → deck default → `fade`, under the motion level. */
+export declare function resolveSlideTransition(input?: SlideTransitionInput): ResolvedTransition;
+export interface DeckSlideTransition {
+    index: number;
+    slideId?: string;
+    transition: ResolvedTransition;
+}
+/** The transition into every slide of a deck, in order. */
+export declare function resolveDeckTransitions(deck: TransitionDeck, options?: MotionOptions): DeckSlideTransition[];
+export type FragmentMotionReason = 'motion-none' | 'reduced-motion' | 'subtle' | 'full';
+export interface ResolvedFragmentMotion {
+    /**
+     * The effect to animate. Moving effects (`fade-up`, `grow`, `shrink`)
+     * become `in` under `none` and reduced motion; the fragment's phase still
+     * comes from its own effect (`fragmentPhase`).
+     */
+    effect: FragmentEffect;
+    durationMs: number;
+    motion: MotionLevel;
+    reason: FragmentMotionReason;
+}
+export interface FragmentMotionOptions extends MotionOptions {
+    deck?: TransitionDeck | null;
+}
+/** How a fragment animates under the motion level. */
+export declare function resolveFragmentMotion(effect: FragmentEffect, options?: FragmentMotionOptions): ResolvedFragmentMotion;