ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/animation-timeline-rows.d.ts

@@ -0,0 +1,78 @@
+/**
+ * `animation-timeline-rows`: merge the editor's own animation list with the
+ * deck's own (native) effect anchors into ONE orderable timeline, so the
+ * authoring panel's drag-to-reorder can target any position in the FULL
+ * sequence, not just among the effects this editor added.
+ *
+ * `PptxSlide.animations` (`PptxElementAnimation[]`) never contains the deck's
+ * own effects: they surface only as read-only
+ * `PptxSlide.animationTimelineAnchors` (see `ooxml-core/pptx`'s
+ * `animation-timeline-anchors` service), grounded in the SAME `order`
+ * numbering space at load time. This module is the pure bridge between the
+ * two: build one merged, sorted row list to render, and reorder it by moving
+ * an editor row to an arbitrary index, deriving new `order` values for every
+ * editor entry (native rows are never written back; their relative order is
+ * implied by where they land in the merged list).
+ *
+ * Pure: imports only `ooxml-core/pptx` types; no framework, no DOM.
+ *
+ * @module render/animation-timeline-rows
+ */
+import type { PptxAnimationTimelineAnchor, PptxElementAnimation } from 'ooxml-core/pptx';
+/** One row in the merged, orderable animation timeline. */
+export type AnimationTimelineRow = {
+    kind: 'editor';
+    /** Stable key for drag-and-drop: one row per editor animation entry. */
+    key: string;
+    order: number;
+    elementId: string;
+} | {
+    kind: 'native';
+    /** Stable key for drag-and-drop: a synthetic id from the anchor's load-time order. */
+    key: string;
+    order: number;
+    targetIds: string[];
+    presetClasses: PptxAnimationTimelineAnchor['presetClasses'];
+};
+/**
+ * Merge `animations` (editor-authored, draggable) with `anchors` (the deck's
+ * own effect groups, read-only) into one row list sorted by `order`.
+ *
+ * Both populations were grounded in the same numbering space at load time
+ * (see core's `computeAnimationTimelineOrder`), so a plain sort interleaves
+ * them correctly with no further reconciliation.
+ */
+export declare function buildAnimationTimelineRows(animations: readonly PptxElementAnimation[], anchors?: readonly PptxAnimationTimelineAnchor[]): AnimationTimelineRow[];
+/**
+ * Move the row identified by `sourceKey` (editor OR native) to `targetIndex`
+ * within the FULL merged sequence, then re-normalise every row's `order` to
+ * a dense 0..n-1. This is the drag-and-drop primitive every binding's
+ * animation timeline calls: unlike the editor-only `reorderAnimationTo`, the
+ * source and target may be a native row, letting an editor-authored effect
+ * land ahead of or behind one of the deck's own.
+ *
+ * A native row can be dragged too (as a drop target resolution convenience);
+ * {@link applyAnimationTimelineOrder} simply never writes a native row's
+ * `order` back anywhere, so moving one only affects where OTHER rows sort
+ * relative to it in this returned list, not the deck's own XML.
+ */
+export declare function reorderAnimationTimelineRows(rows: readonly AnimationTimelineRow[], sourceKey: string, targetIndex: number): AnimationTimelineRow[];
+/**
+ * Write a merged row list's `order` values back onto `animations` (matched by
+ * `elementId`), then sort the result by that new `order` so the returned
+ * array's own position already reflects the drop, matching every binding's
+ * previous editor-only `reorderAnimationTo` contract. Native rows are
+ * read-only and contribute nothing here: their position is implied by the
+ * editor rows sorting around them, not by any field this app persists for
+ * them.
+ */
+export declare function applyAnimationTimelineOrder(animations: readonly PptxElementAnimation[], rows: readonly AnimationTimelineRow[]): PptxElementAnimation[];
+/**
+ * Move one editor animation's row a single step within the FULL merged
+ * timeline (`delta` of -1 or +1), which may cross a native anchor. This is
+ * the one-step "move up" / "move down" button affordance every binding pairs
+ * with drag-and-drop; a no-op (returns `animations` unchanged) when
+ * `elementId` has no row or the step would go out of range.
+ */
+export declare function moveAnimationTimelineRowBy(animations: readonly PptxElementAnimation[], anchors: readonly PptxAnimationTimelineAnchor[], elementId: string, delta: -1 | 1): PptxElementAnimation[];
+//# sourceMappingURL=animation-timeline-rows.d.ts.map

package/dist/pptx/render/animation-timeline-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-rows.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-rows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,2BAA2B,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEzF,2DAA2D;AAC3D,MAAM,MAAM,oBAAoB,GAC7B;IACA,IAAI,EAAE,QAAQ,CAAC;IACf,wEAAwE;IACxE,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACjB,GACD;IACA,IAAI,EAAE,QAAQ,CAAC;IACf,sFAAsF;IACtF,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,aAAa,EAAE,2BAA2B,CAAC,eAAe,CAAC,CAAC;CAC3D,CAAC;AAOL;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACzC,UAAU,EAAE,SAAS,oBAAoB,EAAE,EAC3C,OAAO,GAAE,SAAS,2BAA2B,EAAO,GAClD,oBAAoB,EAAE,CAexB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAC3C,IAAI,EAAE,SAAS,oBAAoB,EAAE,EACrC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GACjB,oBAAoB,EAAE,CAcxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAC1C,UAAU,EAAE,SAAS,oBAAoB,EAAE,EAC3C,IAAI,EAAE,SAAS,oBAAoB,EAAE,GACnC,oBAAoB,EAAE,CAaxB;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACzC,UAAU,EAAE,SAAS,oBAAoB,EAAE,EAC3C,OAAO,EAAE,SAAS,2BAA2B,EAAE,EAC/C,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,GACX,oBAAoB,EAAE,CASxB"}

package/dist/pptx/render/animation-timeline-sequence-builder.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `animation-timeline-sequence-builder` - builds interactive
+ * (`onShapeClick`) and hover (`onHover`) click-group sequences. Split out of
+ * `animation-timeline-builder` to keep that module under the file-size
+ * limit. Pure extraction: no logic changed, only relocated.
+ *
+ * @module render/animation-timeline-sequence-builder
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { AnimationRenderContext } from './animation-render-context.js';
+import type { EffectName, TimelineClickGroup } from './animation-timeline-types.js';
+/**
+ * Count how many dynamic UIDs the interactive sequence builder would consume.
+ * This is used to give the hover sequence builder non-overlapping UIDs.
+ */
+export declare function countDynamicUids(interactiveAnims: Map<string, PptxNativeAnimation[]>): number;
+/**
+ * Build sequence-based click-groups (used for both interactive and hover).
+ */
+export declare function buildSequenceGroups(animsByKey: Map<string, PptxNativeAnimation[]>, entranceIds: Set<string>, neededKeyframes: Set<EffectName>, dynamicBlocks: string[], startUid: number, renderContext?: AnimationRenderContext, pixelateMosaic?: boolean): Map<string, TimelineClickGroup[]>;
+/**
+ * Build hover sequences from onHover animations.
+ * Hover animations are grouped by their target element ID (the element
+ * that the animation applies to). The hover trigger is the element itself
+ * unless a triggerShapeId is specified.
+ */
+export declare function buildHoverSequences(hoverAnims: PptxNativeAnimation[], entranceIds: Set<string>, neededKeyframes: Set<EffectName>, dynamicBlocks: string[], startUid: number, renderContext?: AnimationRenderContext, pixelateMosaic?: boolean): {
+    hoverSequences: Map<string, TimelineClickGroup[]>;
+    nextUid: number;
+};
+//# sourceMappingURL=animation-timeline-sequence-builder.d.ts.map

package/dist/pptx/render/animation-timeline-sequence-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-sequence-builder.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-sequence-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAwB,MAAM,iBAAiB,CAAC;AAWjF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAWzE,OAAO,KAAK,EAAE,UAAU,EAAgB,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAG/F;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,GAAG,MAAM,CAc7F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,EAC9C,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,eAAe,EAAE,GAAG,CAAC,UAAU,CAAC,EAChC,aAAa,EAAE,MAAM,EAAE,EACvB,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,sBAAsB,EAGtC,cAAc,CAAC,EAAE,OAAO,GACtB,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAkLnC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,mBAAmB,EAAE,EACjC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,eAAe,EAAE,GAAG,CAAC,UAAU,CAAC,EAChC,aAAa,EAAE,MAAM,EAAE,EACvB,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,sBAAsB,EAGtC,cAAc,CAAC,EAAE,OAAO,GACtB;IAAE,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAkCxE"}

package/dist/pptx/render/animation-timeline-step-effect.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `animation-timeline-step-effect` - resolves which static effect / dynamic
+ * keyframe / media command a single native animation maps to, plus the
+ * dynamic-uid bookkeeping that goes with it. Split out of
+ * `animation-timeline-regular-step` (itself split out of
+ * `animation-timeline-builder`) to keep these modules under the file-size
+ * limit. Pure extraction: no logic changed, only relocated and threaded
+ * through an explicit return value instead of closure-captured locals.
+ *
+ * @module render/animation-timeline-step-effect
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { AnimationRenderContext } from './animation-render-context.js';
+import type { EffectName } from './animation-timeline-types.js';
+/** Result of resolving one step's effect / dynamic keyframe / command kind. */
+export interface StepEffectResolution {
+    /** Static effect name to add to the timeline's needed-keyframes set, if any. */
+    effect: EffectName | undefined;
+    /** CSS `@keyframes` name for this step (blank for a command step). */
+    keyframe: string;
+    /** Whether this step carries a `p:cmd` media command instead of a visual effect. */
+    isCommand: boolean;
+    /** Whether a `p:tavLst` colour ramp (not `p:animClr`) resolved this step. */
+    tavColorApplied: boolean;
+    /** Dynamic `@keyframes` CSS block to append, if a dynamic keyframe was built. */
+    dynamicCss: string | undefined;
+    /** The dynamic-uid counter value after this step consumed however many it needed. */
+    nextDynamicUid: number;
+    /** True when this animation maps to nothing at all and must be skipped (`continue`). */
+    skip: boolean;
+    /**
+     * CSS easing the step must use instead of its accel/decel easing, when the
+     * keyframes already bake the effect's time warp in (see
+     * `animation-behavior-keyframes`).
+     */
+    easing?: string;
+}
+/**
+ * Resolve a single native animation's effect / dynamic keyframe / command
+ * kind. See `animation-timeline-builder`'s module doc for the overall
+ * click-group grouping this feeds into.
+ */
+export declare function resolveStepEffect(singleAnim: PptxNativeAnimation, renderContext: AnimationRenderContext | undefined, dynamicUidStart: number, includeDirectional?: boolean, pixelateMosaic?: boolean): StepEffectResolution;
+//# sourceMappingURL=animation-timeline-step-effect.d.ts.map

package/dist/pptx/render/animation-timeline-step-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-step-effect.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-step-effect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAM3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAazE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAG7D,+EAA+E;AAC/E,MAAM,WAAW,oBAAoB;IACpC,gFAAgF;IAChF,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;IAC/B,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,SAAS,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,eAAe,EAAE,OAAO,CAAC;IACzB,iFAAiF;IACjF,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,qFAAqF;IACrF,cAAc,EAAE,MAAM,CAAC;IACvB,wFAAwF;IACxF,IAAI,EAAE,OAAO,CAAC;IACd;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,mBAAmB,EAC/B,aAAa,EAAE,sBAAsB,GAAG,SAAS,EACjD,eAAe,EAAE,MAAM,EAKvB,kBAAkB,GAAE,OAAc,EAGlC,cAAc,CAAC,EAAE,OAAO,GACtB,oBAAoB,CA2ItB"}

package/dist/pptx/render/animation-timeline-step-scheduling.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `animation-timeline-step-scheduling` - click-group start/flush decisions
+ * and delay-ms computation for a single step in the main (non-interactive,
+ * non-hover) timeline pass. Split out of `animation-timeline-regular-step`
+ * (itself split out of `animation-timeline-builder`) to keep these modules
+ * under the file-size limit. Pure extraction: no logic changed, only
+ * relocated.
+ *
+ * @module render/animation-timeline-step-scheduling
+ */
+import type { PptxNativeAnimation, PptxAnimationTrigger } from 'ooxml-core/pptx';
+import type { EffectiveStartCondition } from './animation-advanced-triggers.js';
+import type { RegularBuildState } from './animation-timeline-regular-step.js';
+/**
+ * Decide whether `singleAnim` starts a new click-group (flushing the
+ * current one first), track entrance-element visibility, and compute the
+ * step's `delayMs` relative to the start of its click-group. Mutates
+ * `state`'s group/sub-group bookkeeping in place; returns the computed
+ * `delayMs`.
+ */
+export declare function scheduleRegularStep(state: RegularBuildState, singleAnim: PptxNativeAnimation, effective: EffectiveStartCondition, trigger: PptxAnimationTrigger, animDelay: number, triggerDelay: number, presetClass: PptxNativeAnimation['presetClass'] | 'emph', elementId: string): number;
+//# sourceMappingURL=animation-timeline-step-scheduling.d.ts.map

package/dist/pptx/render/animation-timeline-step-scheduling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-step-scheduling.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-step-scheduling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEjF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,iBAAiB,EACxB,UAAU,EAAE,mBAAmB,EAC/B,SAAS,EAAE,uBAAuB,EAClC,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,mBAAmB,CAAC,aAAa,CAAC,GAAG,MAAM,EACxD,SAAS,EAAE,MAAM,GACf,MAAM,CA2FR"}

package/dist/pptx/render/animation-timeline-step.d.ts

@@ -0,0 +1,220 @@
+/**
+ * `animation-timeline-step` - the per-step timeline models
+ * ({@link AnimationStep}, {@link TimelineStepCommand}, {@link TimelineStep}),
+ * split out of `animation-timeline-types` to keep that module under the
+ * file-size limit. Re-exported from `animation-timeline-types` so existing
+ * imports are unaffected.
+ *
+ * @module render/animation-timeline-step
+ */
+import type { AnimationConditionEvent, PptxAnimationTrigger } from 'ooxml-core/pptx';
+import type { TextStyleAnimationDescriptor } from './animation-text-style-resolve.js';
+import type { ColorAnimationTarget, StepBuildDescriptor, TimelineStepGraphicElement } from './animation-timeline-build-descriptors.js';
+/** A single sequenced animation step used by the flat-sequence builder. */
+export interface AnimationStep {
+    elementId: string;
+    trigger: PptxAnimationTrigger;
+    delayMs: number;
+    durationMs: number;
+    cssKeyframes: string;
+    cssAnimation: string;
+    fillMode: 'forwards' | 'backwards' | 'both';
+}
+/**
+ * A media playback command carried by a timeline step, parsed from an OOXML
+ * `p:cmd` node in the timing tree. Unlike a visual animation step, a command
+ * step applies no CSS: it instructs the playback layer to drive a media element
+ * (play/pause/seek) when the step fires. The command participates in click-group
+ * sequencing exactly like a visual step so it triggers at the correct time.
+ */
+export interface TimelineStepCommand {
+    /** OOXML `p:cmd/@type` verb family: `call`, `evt`, or `verb`. */
+    type?: string;
+    /** OOXML `p:cmd/@cmd` string, e.g. `playFrom(0.0)`, `pause`, `play`, `stop`. */
+    command: string;
+    /** Target element/shape id the command acts on (from `p:tgtEl`). */
+    targetId: string;
+}
+/** A single animation applied to one element within a click-group. */
+export interface TimelineStep {
+    /** Target element ID. */
+    elementId: string;
+    /** CSS animation shorthand to apply (e.g. "pptx-fadeIn 500ms ease 0ms 1 both"). */
+    cssAnimation: string;
+    /** Name of the CSS @keyframes rule (e.g. "pptx-fadeIn"). */
+    keyframeName: string;
+    /** Trigger that produced this step. */
+    trigger: PptxAnimationTrigger;
+    /** Delay in ms relative to the start of the click-group. */
+    delayMs: number;
+    /** Duration in ms of the animation. */
+    durationMs: number;
+    /** CSS animation fill mode. */
+    fillMode: 'forwards' | 'backwards' | 'both';
+    /** Preset class for determining visibility semantics. */
+    presetClass: 'entr' | 'exit' | 'emph' | 'path';
+    /** Resolved sound file path to play when this step triggers. */
+    soundPath?: string;
+    /** Whether to stop any currently playing animation sound. */
+    stopSound?: boolean;
+    /**
+     * Media playback command from a `p:cmd` timing node. When present, this step
+     * carries no visual animation (`elementId` is empty and `cssAnimation` is a
+     * blank string); the playback layer acts on the referenced media element
+     * instead. See {@link TimelineStepCommand}.
+     */
+    command?: TimelineStepCommand;
+    /**
+     * Staged-build descriptor when this step reveals a chart / SmartArt diagram
+     * in stages (`p:bldChart` / `p:bldDgm`) rather than as one whole element.
+     * Present alongside the normal `cssAnimation` (the wrapper still fades in);
+     * a staged-reveal renderer additionally reads the descriptor + the step's
+     * {@link delayMs}/{@link durationMs} to compute how much is revealed over
+     * time. Absent for ordinary whole-element entrances.
+     */
+    build?: StepBuildDescriptor;
+    /**
+     * `p:spTgt/p:graphicEl` index data from this step's source animation
+     * target, when present (a per-series/per-category chart or diagram build
+     * effect). See {@link TimelineStepGraphicElement} and
+     * `chart-reveal-descriptor`.
+     */
+    graphicElement?: TimelineStepGraphicElement;
+    /**
+     * Shape paint targets of an active `p:animClr` color animation on this step,
+     * if any. Lets a vector renderer set `fill: inherit` / `stroke: inherit` on
+     * the painted path so the wrapper-level colour keyframes cascade through.
+     */
+    colorTargets?: readonly ColorAnimationTarget[];
+    /**
+     * True when the playback layer must keep this step's CSS animation attached
+     * after it finishes rather than clearing it on cleanup, so the effect's
+     * final frame persists (OOXML `p:cTn/@fill="hold"` or `"freeze"`).
+     *
+     * Only meaningful for `emph` / `path` steps: an `entr` step's held state is
+     * already its resting (un-animated) style, so clearing is harmless there,
+     * and `exit` visibility is governed separately by `presetClass`. Without
+     * this, an emphasis colour/scale change or a motion path's final position
+     * snapped back to the pre-effect style a few ms after every effect
+     * finished, because clearing the CSS `animation` shorthand drops its
+     * `fill-mode` along with it.
+     */
+    holdEndState?: boolean;
+    /**
+     * True when `afterAnimation: "hideAfterAnimation"` applies to this step:
+     * the element should hide once the effect's active window ends, even
+     * though the effect itself is an entrance or emphasis (which otherwise
+     * leave the element visible). See `animation-after-effect` in
+     * `pptx-viewer-shared`.
+     */
+    hideAfterEffect?: boolean;
+    /**
+     * True when `afterAnimation: "hideOnNextClick"` applies to this step.
+     * `injectHideOnNextClickSteps` consumes this during timeline construction
+     * to splice a synthetic hide step into the following click-group; it is
+     * left on the original step afterward purely as informational metadata.
+     */
+    pendingHideOnNextClick?: boolean;
+    /**
+     * The CSS `animation` shorthand for a pending `afterAnimation: "dimToColor"`
+     * dim, when the dim has not fired yet. PowerPoint writes the dim as
+     * `masterRel="nextClick"` and, COM-verified, it consumes a click of its own
+     * rather than firing when the effect itself ends. `injectHideOnNextClickSteps`
+     * consumes this during timeline construction to splice a synthetic step
+     * carrying this CSS into the following click-group; it is left on the
+     * original step afterward purely as informational metadata.
+     */
+    pendingDimOnNextClick?: string;
+    /**
+     * Restart behaviour from `p:cTn/@restart` (ST_TLTimeNodeRestartType,
+     * ECMA-376 S19.5.27), forwarded from the source `PptxNativeAnimation`.
+     * `TimelineEngine` reads this to decide whether a re-trigger of this same
+     * step (an interactive/hover sequence replayed, or a slide reset) is
+     * allowed while the step's previous run is still active, or at all.
+     * Absent means the OOXML default (`always`: no restriction).
+     */
+    restart?: 'always' | 'whenNotActive' | 'never';
+    /**
+     * True when this step's repeat is PowerPoint's "Repeat until next click":
+     * an infinitely-repeating (`iterCount === Infinity`) effect whose
+     * `p:endCondLst` resolves to `endsOnClick`/`onNext`
+     * ({@link import('./animation-advanced-triggers').resolveAnimationEnd}),
+     * or whose `restart` is `whenNotActive` (how this project's own editor
+     * writes `repeatMode: "untilNextClick"`, see
+     * `animation-write-node-effect.ts`). `TimelineEngine.advance()` reads this
+     * to freeze the running CSS loop, in place, the next time the presentation
+     * advances, rather than letting it repeat forever.
+     */
+    endsOnNextClick?: boolean;
+    /**
+     * `p:seq/@concurrent` of the innermost enclosing sequence, if any (ECMA-376
+     * S19.5.60), forwarded from the source `PptxNativeAnimation`. Rolled up
+     * onto the owning {@link import('./animation-timeline-group').TimelineClickGroup}
+     * by `finalizeClickGroup`; see that type's own field for the playback
+     * meaning.
+     */
+    seqConcurrent?: boolean;
+    /** `p:seq/@nextAc` of the innermost enclosing sequence, if any. */
+    seqNextAction?: 'none' | 'seek';
+    /** `p:seq/@prevAc` of the innermost enclosing sequence, if any. */
+    seqPrevAction?: 'none' | 'skipTimeNode';
+    /**
+     * Id of the `p:excl` container this step's effect belongs to, when it is
+     * inside one (ECMA-376 S19.5.24 CT_TLExclusiveTimeNode: at most one direct
+     * child of an exclusive container plays at a time). {@link TimelineEngine}
+     * uses this to stop any other element's currently-running animation that
+     * shares the same id when this step starts. Absent for steps outside any
+     * exclusive container.
+     */
+    exclGroupId?: number;
+    /**
+     * `p:cond/@tn` (ECMA-376 S19.5.28) this step's start condition depends on, a
+     * SPECIFIC time node id rather than a positional "the previous step". Only
+     * `dependsOnEvent === 'onStopAudio'` is consumed at playback today (see
+     * `animation-media-end-gating`'s `findMediaEndGatedSteps`): the referenced
+     * node's already-computed `delayMs`/`durationMs` fed into THIS step's own
+     * `delayMs` at build time (`animation-timeline-builder`) is only an
+     * ESTIMATE for a media node, since the real clip's playback duration is not
+     * knowable ahead of time (trimmed, or simply variable-length audio); a
+     * binding wires the referenced `<audio>`/`<video>` element's real `ended`
+     * event to start this step immediately instead, falling back to the
+     * estimate when no such element exists (export/headless). Other
+     * `dependsOnEvent` values (`onBegin`/`onEnd`) already resolve correctly via
+     * the computed delay alone, since a non-media node's `durationMs` is exact.
+     * Mutually exclusive with {@link dependsOnShapeId}: an OOXML `p:cond` names
+     * its dependency by EITHER a time-node id OR a shape, never both.
+     */
+    dependsOnTimeNodeId?: number;
+    /**
+     * `p:cond/@evt="onStopAudio"` naming its dependency by SHAPE instead of
+     * time-node id (`p:tgtEl/p:spTgt/@_spid`, no `@_tn`): the media element's
+     * own shape/element id, in the same id space as {@link elementId} and
+     * `data-element-id`. `animation-media-end-gating`'s `wireMediaEndedSteps`
+     * resolves this directly against the live DOM (no node-id -> element-id map
+     * needed, unlike {@link dependsOnTimeNodeId}). See
+     * `EffectiveStartCondition.dependsOnShapeId` in `animation-advanced-triggers`
+     * for why this alternative form exists.
+     */
+    dependsOnShapeId?: string;
+    /** The event of the time-node/shape dependency above, when present. */
+    dependsOnEvent?: AnimationConditionEvent;
+    /**
+     * When {@link dependsOnEvent} is `onMediaBookmark`, the bookmark name this
+     * step waits on; {@link dependsOnShapeId} names the media element it
+     * belongs to. See `animation-media-bookmark-gating`'s
+     * `wireMediaBookmarkSteps`.
+     */
+    dependsOnBookmarkName?: string;
+    /**
+     * Discrete font-style / colour / size override this step's effect composes
+     * via `p:set` siblings and/or a `style.fontsize`/boolean `p:anim` ramp (Bold
+     * Flash, Bold Reveal, Underline, Brush On Underline, Change Font Style,
+     * Change Font Size), resolved by `resolveTextStyleAnimation`
+     * (`animation-text-style-resolve.ts`). Absent for every effect that carries
+     * none of those attrs, so existing renderers are unaffected. See
+     * {@link import('./animation-timeline-group').ElementAnimationState.textStyle}
+     * for how the playback engine carries this through step start / cleanup.
+     */
+    textStyle?: TextStyleAnimationDescriptor;
+}
+//# sourceMappingURL=animation-timeline-step.d.ts.map

package/dist/pptx/render/animation-timeline-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-step.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-step.ts"],"names":[],"mappings":"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"}

package/dist/pptx/render/animation-timeline-text-build-pieces.d.ts

@@ -0,0 +1,93 @@
+/**
+ * `animation-timeline-text-build-pieces`: the per-letter / per-word split
+ * used by text-build expansion (`animation-timeline-text-build`), plus the
+ * segment-count type and composite-id separator both modules share. Split out
+ * to keep each module under the repo's file-size guideline.
+ *
+ * @module render/animation-timeline-text-build-pieces
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+/** Paragraph / word / character counts used to expand text-build animations. */
+export interface TextBuildSegmentCounts {
+    /** Number of paragraphs in the text body. */
+    paragraphCount: number;
+    /** Number of words per paragraph (undefined when not needed). */
+    wordCounts?: number[];
+    /** Number of characters per paragraph (undefined when not needed). */
+    charCounts?: number[];
+    /**
+     * 0-based outline level per paragraph (`a:p/@lvl`, `TextSegment.paragraphLevel`),
+     * used by a `bldLvl`-aware "by paragraph" build to decide which paragraphs
+     * open their own click step. Absent entries default to level 0.
+     */
+    paragraphLevels?: number[];
+}
+/**
+ * Separator used between element ID and sub-element identifier
+ * in composite animation target IDs (e.g. `"shape3::p0"`).
+ */
+export declare const TEXT_BUILD_ID_SEP = "::";
+/**
+ * Stagger (ms) between consecutive sub-elements of an `p:iterate` build.
+ *
+ * `p:tmAbs` is already milliseconds; `p:tmPct` is a percentage of the effect's
+ * own duration in 1000ths of a percent (PowerPoint's default is `10000`, i.e.
+ * 10%). A ZERO interval is meaningful: PowerPoint plays "by letter" with a 0%
+ * delay as all letters simultaneously, so `0` must be returned as `0` (every
+ * piece starts together), NOT collapsed to `undefined`. Falling through to the
+ * `undefined` sequential fallback chained each letter after the previous one's
+ * full duration, turning an instant reveal into a multi-second crawl that also
+ * pushed every later effect in the group tens of seconds out (issue #132).
+ * Returns `undefined` only when the animation is not iterate-driven at all, so
+ * the caller keeps the slide-build defaults.
+ */
+export declare function iterateStaggerMs(anim: PptxNativeAnimation, durationMs: number): number | undefined;
+/** A `<baseId>::p<N>` paragraph-scoped target id, split into its parts. */
+export interface ParagraphScopedTarget {
+    baseId: string;
+    paragraph: number;
+}
+/** Parse a paragraph-scoped composite target id (`shape3::p1`), if it is one. */
+export declare function parseParagraphScopedTarget(targetId: string): ParagraphScopedTarget | undefined;
+/**
+ * The within-paragraph granularity an effect's own `p:iterate` asks for, or
+ * `undefined` when it animates the text as one object (`type="el"`, or absent).
+ *
+ * This is INDEPENDENT of `p:bldP/@build`: the slide build says how the text is
+ * grouped into steps ("by paragraph"), while `p:iterate` says how each step is
+ * subdivided in time ("by letter"). PowerPoint composes the two; reading only
+ * the build type made a by-paragraph credit line authored to ripple in letter by
+ * letter appear as one solid block (issue #106).
+ */
+export declare function iterateGranularity(anim: Pick<PptxNativeAnimation, 'iterate'>): 'byChar' | 'byWord' | undefined;
+/**
+ * Piece pacing for a split with no `p:iterate` interval (a plain `p:bldP`
+ * by-word / by-letter build): each piece plays a shortened effect, chained
+ * end to end with a small gap.
+ */
+export declare function fallbackPiecePacing(kind: 'byChar' | 'byWord', baseDuration: number): {
+    durationMs: number;
+    staggerMs: number;
+};
+/** Per-piece sub-element id prefix and per-paragraph piece count for a split. */
+export declare function pieceCounts(kind: 'byChar' | 'byWord', counts: TextBuildSegmentCounts): {
+    token: 'c' | 'w';
+    perParagraph: number[];
+};
+/**
+ * Emit one staggered sub-animation per letter / word.
+ *
+ * An `p:iterate` build overlaps: every piece runs the FULL effect duration and
+ * merely starts `stagger` later than the one before, which is what makes
+ * PowerPoint's "by letter" read as a ripple. `withPrevious` steps accumulate
+ * their delay from the previous step's START, so passing the bare interval as
+ * each step's delay yields `base + i * stagger`. The slide-build (`p:bldP`) path
+ * keeps its original end-to-end pacing.
+ *
+ * With `onlyParagraph` the split is limited to that one paragraph: that is how
+ * PowerPoint writes each step of a "By paragraph" build (one effect per
+ * paragraph, scoped by `p:txEl/p:pRg`). A by-paragraph build carried by ONE
+ * whole-shape effect goes through `emitParagraphGroupRipple` instead.
+ */
+export declare function emitStaggeredPieces(anim: PptxNativeAnimation, kind: 'byChar' | 'byWord', counts: TextBuildSegmentCounts, output: PptxNativeAnimation[], onlyParagraph?: ParagraphScopedTarget): void;
+//# sourceMappingURL=animation-timeline-text-build-pieces.d.ts.map

package/dist/pptx/render/animation-timeline-text-build-pieces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-text-build-pieces.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-text-build-pieces.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACtC,6CAA6C;IAC7C,cAAc,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,mBAAmB,EACzB,UAAU,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAepB;AAED,2EAA2E;AAC3E,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,iFAAiF;AACjF,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAU9F;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC,GACxC,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAQjC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,QAAQ,GAAG,QAAQ,EACzB,YAAY,EAAE,MAAM,GAClB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAI3C;AAED,iFAAiF;AACjF,wBAAgB,WAAW,CAC1B,IAAI,EAAE,QAAQ,GAAG,QAAQ,EACzB,MAAM,EAAE,sBAAsB,GAC5B;IAAE,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,CAI9C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,QAAQ,GAAG,QAAQ,EACzB,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,mBAAmB,EAAE,EAC7B,aAAa,CAAC,EAAE,qBAAqB,GACnC,IAAI,CAoDN"}

package/dist/pptx/render/animation-timeline-text-build-ripple.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `animation-timeline-text-build-ripple`: the per-letter / per-word ripple of
+ * ONE click step of a "By paragraph" text build whose effect also carries
+ * `p:iterate type="lt" | "wd"` (Effect Options > Animate text: By letter / By
+ * word), split out of `animation-timeline-text-build` to keep each module
+ * under the repo's file-size guideline.
+ *
+ * PowerPoint ground truth (CreateVideo captures of Fade, 1 s, tmPct 10%):
+ * - every letter plays the FULL effect duration and starts one interval after
+ *   the previous letter of its own paragraph, so a 6-letter step lasts
+ *   `dur + 5 * interval` (1000 + 5 * 100 = 1500 ms);
+ * - a sub-level paragraph grouped into the step by `p:bldP/@bldLvl` ripples
+ *   IN PARALLEL with its opener (both first letters at the step start),
+ *   instead of continuing the opener's ripple;
+ * - `p:iterate/@backwards` reverses the letters within each paragraph only.
+ *
+ * @module render/animation-timeline-text-build-ripple
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { TextBuildSegmentCounts } from './animation-timeline-text-build-pieces.js';
+/** How the first step of a by-paragraph build group starts. */
+export type RippleGroupHead = Pick<PptxNativeAnimation, 'trigger' | 'triggerDelayMs' | 'delayMs' | 'startConditions' | 'parGroupIndex' | 'parGroupDelayMs'>;
+/**
+ * Emit one click step (a `bldLvl` paragraph group) of a by-paragraph build as
+ * staggered per-letter / per-word sub-animations.
+ *
+ * Every member paragraph's ripple starts at the step start; the pieces are
+ * then ordered by start offset and chained as `withPrevious` steps whose delay
+ * is the gap from the previous piece's start (the scheduler measures a
+ * `withPrevious` delay from the previous step's START). The first piece
+ * carries `head`, which decides whether the step waits for a click, follows
+ * the previous effect, or starts after an `advAuto` delay.
+ *
+ * A group without any piece (only empty paragraphs) still emits one
+ * paragraph-scoped step, so the click count matches PowerPoint's.
+ */
+export declare function emitParagraphGroupRipple(anim: PptxNativeAnimation, kind: 'byChar' | 'byWord', counts: TextBuildSegmentCounts, members: readonly number[], head: RippleGroupHead, output: PptxNativeAnimation[]): void;
+//# sourceMappingURL=animation-timeline-text-build-ripple.d.ts.map

package/dist/pptx/render/animation-timeline-text-build-ripple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-text-build-ripple.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-text-build-ripple.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAQ3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAErF,+DAA+D;AAC/D,MAAM,MAAM,eAAe,GAAG,IAAI,CACjC,mBAAmB,EACnB,SAAS,GAAG,gBAAgB,GAAG,SAAS,GAAG,iBAAiB,GAAG,eAAe,GAAG,iBAAiB,CAClG,CAAC;AAiBF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACvC,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,QAAQ,GAAG,QAAQ,EACzB,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,mBAAmB,EAAE,GAC3B,IAAI,CAyDN"}

package/dist/pptx/render/animation-timeline-text-build.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `animation-timeline-text-build`: pure expansion of text-build animations
+ * (by-paragraph / by-word / by-char) into staggered per-segment sub-animations.
+ *
+ * @module render/animation-timeline-text-build
+ */
+import type { PptxNativeAnimation, PptxTextBuildType } from 'ooxml-core/pptx';
+import type { TextBuildSegmentCounts } from './animation-timeline-text-build-pieces.js';
+export type { TextBuildSegmentCounts } from './animation-timeline-text-build-pieces.js';
+export { TEXT_BUILD_ID_SEP } from './animation-timeline-text-build-pieces.js';
+/**
+ * Count paragraphs, words and characters from an element's text segments.
+ * Paragraph boundaries are segments whose text is exactly `"\n"`. A
+ * paragraph's outline level comes from its first segment's
+ * `paragraphLevel` (mirroring the `bulletInfo` convention), defaulting to 0.
+ */
+export declare function countTextSegments(textSegments: ReadonlyArray<{
+    text: string;
+    paragraphLevel?: number;
+}>): TextBuildSegmentCounts;
+/**
+ * The build granularity an animation actually wants, from either of the two
+ * places OOXML records it.
+ *
+ * `p:bldP/@build` (parsed to `buildType`) is the slide-level text build, but
+ * PowerPoint's "Effect Options > Animate text: By letter / By word" writes
+ * `p:iterate` on the effect's own `p:cTn` instead. Only the first was honoured,
+ * so a title authored to fade in letter by letter faded in as one block
+ * (issue #106). `p:iterate type="el"` means "as one object" and stays
+ * unexpanded.
+ */
+export declare function effectiveTextBuildType(anim: Pick<PptxNativeAnimation, 'buildType' | 'iterate'>): PptxTextBuildType | undefined;
+/**
+ * Expand text-build animations into per-paragraph, per-word or per-character
+ * sub-element animations.
+ *
+ * - **byParagraph**: each paragraph becomes its own click-group entry (trigger: onClick).
+ * - **byWord**: words within each paragraph stagger with afterPrevious within same click.
+ * - **byChar**: characters stagger with afterPrevious within same click.
+ *
+ * @param animations - Original animations (some may have `buildType` set).
+ * @param segmentCounts - Map of elementId → segment counts from `countTextSegments()`.
+ * @returns Expanded animation list with composite target IDs.
+ */
+export declare function expandTextBuildAnimations(animations: ReadonlyArray<PptxNativeAnimation>, segmentCounts: ReadonlyMap<string, TextBuildSegmentCounts>): PptxNativeAnimation[];
+//# sourceMappingURL=animation-timeline-text-build.d.ts.map

package/dist/pptx/render/animation-timeline-text-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-timeline-text-build.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-timeline-text-build.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAS9E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAGrF,YAAY,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACrF,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAM3E;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAChC,YAAY,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACpE,sBAAsB,CA6BxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,GAAG,SAAS,CAAC,GACtD,iBAAiB,GAAG,SAAS,CAW/B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACxC,UAAU,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAC9C,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,GACxD,mBAAmB,EAAE,CA6CvB"}