Web Animations Level 2

1. Delta specification

This is a delta specification, meaning that it currently contains only the differences from Web Animations Level 1 [WEB-ANIMATIONS-1]. Once the Level 1 specification is closer to complete, it will be merged with the additions here into a complete level 2 specification.

2. Changes since level 1

This specification introduces the following changes compared to the previous level of this specification:

• group effects and sequence effects,

• an animation effect-specific playback rate,

• Support for non-monotonic (scroll) timelines.

3. Timing model

This section describes and defines the behavior of the Web Animations timing model.

3.1. Timing model overview

This section is non-normative

3.1.1. Hierarchical

This level of the specification includes an updated timing hierarchy diagram.

Along with the following updated description:

A consequence of this hierarchical arrangement is that complex animation arrangements can be reversed, scheduled, accelerated and so on as a whole unit since the manipulations applied to the parent, cascade down to its descendants. Furthermore, since time has a common source, it is easy to synchronize animations.

3.2. Timelines

Add:

The duration of a timeline gives the maximum value a timeline may generate for its current time. This value is used to calculate the intrinsic iteration duration for the target effect of an animation that is associated with the timeline when the effect’s iteration duration is "auto". The value is computed such that the effect fills the available time. For a monotonic timeline, there is no upper bound on current time, and timeline duration is unresolved. For a non-monotonic (e.g. scroll) timeline, the duration has a fixed upper bound. In this case, the timeline is a progress-based timeline, and its timeline duration is 100%.

3.3. Animations

Append:

Animation effects associated with a progress-based timeline require their timing properties to be converted to proportions. The procedure for converting a is as follows:

1. If the iteration duration is auto, then perform the following steps.

   • Set start delay and end delay to 0, as it is not possible to mix time and proportions.

     Note: Future versions may allow these properties to be assigned percentages, at which point the delays are only to be ignored if their values are expressed as times and not as percentages.

   Otherwise:

   1. Let total time be equal to end time

   2. Set start delay to be the result of evaluating specified start delay / total time * timeline duration.

   3. Set iteration duration to be the result of evaluating specified iteration duration / total time * timeline duration.

   4. Set end delay to be the result of evaluating specified end delay / total time * timeline duration.

The procedure to normalize specified timing is as follows:

If timeline duration is resolved:

• Follow the procedure to convert a time-based animation to a proportional animation

Otherwise:

1. Set start delay = specified start delay

2. Set end delay = specified end delay

3. If iteration duration is auto:

   • Set iteration duration = intrinsic iteration duration

   Otherwise:

   • Set iteration duration = specified iteration duration

3.3.1. Setting the timeline of an animation

The procedure to set the timeline of an animation, animation, to new timeline which may be null, is as follows:

1. Let old timeline be the current timeline of animation, if any.

2. If new timeline is the same object as old timeline, abort this procedure.

3. Let previous play state be animation’s play state.

4. Let previous current time be the animation’s current time.

5. Set previous progress based in the first condition that applies:

   If previous current time is unresolved:

   Set previous progress to unresolved.

   If end time is zero:

   Set previous progress to zero.

   Otherwise

   Set previous progress = previous current time / end time

6. Let from finite timeline be true if old timeline is not null and not monotonically increasing.

7. Let to finite timeline be true if timeline is not null and not monotonically increasing.

8. Let the timeline of animation be new timeline.

9. Set the flag reset current time on resume to false.

10. Perform the steps corresponding to the first matching condition from the following, if any:

    If to finite timeline,

    1. Apply any pending playback rate on animation

    2. Let seek time be zero if playback rate ≥ 0, and animation’s associated effect end otherwise.

    3. Update the animation based on the first matching condition if any:

       If either of the following conditions are true:

       • previous play state is "running" or,

       • previous play state is "finished"

       Set animation’s start time to seek time.

       If previous play state is "paused":

       If previous progress is resolved:

       1. Set the flag reset current time on resume to true.

       2. Set start time to unresolved.

       3. Set hold time to previous progress * end time.

       This step ensures that previous progress is preserved even in the case of a pause-pending animation with a resolved start time.

       Otherwise

       1. Set start time to seek time.

    If from finite timeline and previous progress is resolved,

    Run the procedure to set the current time to previous progress * end time.

11. If the start time of animation is resolved, make animation’s hold time unresolved.

    This step ensures that the finished play state of animation is not “sticky” but is re-evaluated based on its updated current time.

12. Run the procedure to update an animation’s finished state for animation with the did seek flag set to false, and the synchronously notify flag set to false.

3.3.2. Setting the target effect of an animation

After the step to reschedule a pending play task add the following step:

1. If new effect is not null and if new effect has a parent group, remove new effect from its parent group.

3.3.3. Waiting for the associated effect

The definition of when an animation is ready needs to be extended to consider descendant effects and custom effects such that the first condition is:

• the user agent has completed any setup required to begin the playback of each inclusive descendant of the animation’s associated effect including rendering the first frame of any keyframe effect or executing any custom effects associated with an animation effect .

3.3.4. Validating a CSSNumberish time

The procedure to validate a CSSNumberish time for an input value of time is based on the first condition that matches:

If all of the following conditions are true:

• The animation is associated with a progress-based timeline, and

• time is not a CSSNumeric value with percent units:

throw a TypeError.

return false;

If all of the following conditions are true:

• The animation is not associated with a progress-based timeline, and

• time is a CSSNumericValue, and

• the units of time are not duration units:

throw a TypeError.

return false.

Oterwise

return true.

3.3.5. Setting the current time of an Animation

The current time of an animation can be set to a new value to seek the animation. The procedure for setting the current time is defined in two parts.

The procedure to silently set the current time of an animation, animation, to seek time is as follows:

1. If seek time is an unresolved time value, then perform the following steps.

   1. If the current time is resolved, then throw a TypeError.

   2. Abort these steps.

2. Let valid seek time be the result of running the validate a CSSNumberish time procedure with seek time as the input.

3. If valid seek time is false, abort this procedure.

4. Update either animation’s hold time or start time as follows:

   If any of the following conditions are true:

   • animation’s hold time is resolved, or

   • animation’s start time is unresolved, or

   • animation has no associated timeline or the associated timeline is inactive, or

   • animation’s playback rate is 0,

   1. Set animation’s hold time to seek time.

   Otherwise,

   Set animation’s start time to the result of evaluating timeline time - (seek time / playback rate) where timeline time is the current time value of timeline associated with animation.

5. If animation has no associated timeline or the associated timeline is inactive, make animation’s start time unresolved.

   This preserves the invariant that when we don’t have an active timeline it is only possible to set either the start time or the animation’s current time.

6. Make animation’s previous current time unresolved.

7. Set the reset current time on resume flag to false.

The procedure to set the current time of an animation, animation, to seek time is as follows:

1. Run the steps to silently set the current time of animation to seek time.

2. If animation has a pending pause task, synchronously complete the pause operation by performing the following steps:

   1. Set animation’s hold time to seek time.

   2. Apply any pending playback rate to animation.

   3. Make animation’s start time unresolved.

   4. Cancel the pending pause task.

   5. Resolve animation’s current ready promise with animation.

3. Run the procedure to update an animation’s finished state for animation with the did seek flag set to true, and the synchronously notify flag set to false.

3.3.6. Setting the start time of an Animation

The procedure to set the start time of animation, animation, to new start time, is as follows:

1. Let valid start time be the result of running the validate a CSSNumberish time procedure with new start time as the input.

2. If valid start time is false, abort this procedure.

3. Let timeline time be the current time value of the timeline that animation is associated with. If there is no timeline associated with animation or the associated timeline is inactive, let the timeline time be unresolved.

4. If timeline time is unresolved and new start time is resolved, make animation’s hold time unresolved.

   This preserves the invariant that when we don’t have an active timeline it is only possible to set either the start time or the animation’s current time.

5. Let previous current time be animation’s current time.

   Note: This is the current time after applying the changes from the previous step which may cause the current time to become unresolved.

6. Apply any pending playback rate on animation.

7. Set animation’s start time to new start time.

8. Set the reset current time on resume flag to false.

9. Update animation’s hold time based on the first matching condition from the following,

   If new start time is resolved,

   If animation’s playback rate is not zero, make animation’s hold time unresolved.

   Otherwise (new start time is unresolved),

   1. Set animation’s hold time to previous current time even if previous current time is unresolved.

10. If animation has a pending play task or a pending pause task, cancel that task and resolve animation’s current ready promise with animation.

11. Run the procedure to update an animation’s finished state for animation with the did seek flag set to true, and the synchronously notify flag set to false.

3.3.7. Playing an animation

The procedure to play an animation, animation, given a flag auto-rewind, is as follows:

Note: The auto-rewind flag is provided for other specifications that build on this model but do not require the rewinding behavior, such as CSS Animations [CSS-ANIMATIONS-1].

1. Let aborted pause be a boolean flag that is true if animation has a pending pause task, and false otherwise.

2. Let has pending ready promise be a boolean flag that is initially false.

3. Let seek time be a time value that is initially unresolved.

4. Let has finite timeline be true if animation has an associated timeline that is not monotonically increasing.

5. Let previous current time be the animation’s current time

6. If reset current time on resume is set:

   • Set previous current time to unresolved.

   • Set the reset current time on resume flag to false.

7. Perform the steps corresponding to the first matching condition from the following, if any:

   If animation’s effective playback rate > 0, the auto-rewind flag is true and either animation’s:

   • previous current time is unresolved, or

   • previous current time < zero, or

   • previous current time ≥ associated effect end,

   Set seek time to zero.

   If animation’s effective playback rate < 0, the auto-rewind flag is true and either animation’s:

   • previous current time is unresolved, or

   • previous current time ≤ zero, or

   • previous current time > associated effect end,

   If associated effect end is positive infinity,

   throw an "InvalidStateError" DOMException and abort these steps.

   Otherwise,

   Set seek time to animation’s associated effect end.

   If animation’s effective playback rate = 0 and animation’s current time is unresolved,

   Set seek time to zero.

8. If seek time is resolved,

   If has finite timeline is true,

   1. Set animation’s start time to seek time.

   2. Let animation’s hold time be unresolved.

   3. Apply any pending playback rate on animation.

   Otherwise,

   1. Set animation’s hold time to seek time.

9. If animation’s hold time is resolved, let its start time be unresolved.

10. If animation has a pending play task or a pending pause task,

    1. Cancel that task.

    2. Set has pending ready promise to true.

11. If the following four conditions are all satisfied:

    • animation’s hold time is unresolved, and

    • seek time is unresolved, and

    • aborted pause is false, and

    • animation does not have a pending playback rate,

    abort this procedure.

12. If has pending ready promise is false, let animation’s current ready promise be a new promise in the relevant Realm of animation.

13. Schedule a task to run as soon as animation is ready. The task shall perform the following steps:

    1. Assert that at least one of animation’s start time or hold time is resolved.

    2. Let ready time be the time value of the timeline associated with animation at the moment when animation became ready.

    3. Perform the steps corresponding to the first matching condition below, if any:

       If animation’s hold time is resolved,

       1. Apply any pending playback rate on animation.

       2. Let new start time be the result of evaluating ready time - hold time / playback rate for animation. If the playback rate is zero, let new start time be simply ready time.

       3. Set the start time of animation to new start time.

       4. If animation’s playback rate is not 0, make animation’s hold time unresolved.

       If animation’s start time is resolved and animation has a pending playback rate,

       1. Let current time to match be the result of evaluating (ready time - start time) × playback rate for animation.

       2. Apply any pending playback rate on animation.

       3. If animation’s playback rate is zero, let animation’s hold time be current time to match.

       4. Let new start time be the result of evaluating ready time - current time to match / playback rate for animation. If the playback rate is zero, let new start time be simply ready time.

       5. Set the start time of animation to new start time.

    4. Resolve animation’s current ready promise with animation.

    5. Run the procedure to update an animation’s finished state for animation with the did seek flag set to false, and the synchronously notify flag set to false.

       Note that the order of the above two steps is important since it means that an animation with zero-length associated effect will resolve its current ready promise before its current finished promise.

    So long as the above task is scheduled but has yet to run, animation is described as having a pending play task. While the task is running, however, animation does not have a pending play task.

    If a user agent determines that animation is immediately ready, it may schedule the above task as a microtask such that it runs at the next microtask checkpoint, but it must not perform the task synchronously.

    The above requirement to run the pending play task asynchronously ensures that code such as the following behaves consistently between implementations:

    animation.play();
    animation.ready.then(
      () => { console.log('Playback commenced'); },
      () => { console.log('Playback was canceled'); }
    );
    // Suppose some condition requires playback to be canceled...
    animation.cancel();
    // "Playback was canceled" will be printed to the console.
    

    In the above code, were the pending play task run synchronously, the current ready promise would not be rejected.

14. Run the procedure to update an animation’s finished state for animation with the did seek flag set to false, and the synchronously notify flag set to false.

The procedure to play an animation needs to include scheduling a task for updating custom effects.

3.3.8. Pausing an animation

The procedure to pause an animation needs to refer not only to the associated effect but also any descendants of the associated effect.

3.3.9. Canceling an animation

3.3.10. Speed control

3.4. Animation effects

Adds the following text:

The associated effect of an animation is said to be directly associated with that animation.

Animation effects can be combined together into a hierarchy using group effects (see § 3.9 Grouping and synchronization). Only the root animation effect of such a hierarchy can be directly associated with an animation. If an animation effect that has a parent group is designated as the associated effect of an animation, the animation effect is removed from its parent group before being associated with the animation.

An animation effect is associated with an animation if it is directly associated with an animation or if it has an ancestor group effect that is directly associated with an animation.

3.4.1. Types of animation effects

This specification defines two types of animation effects:

• keyframe effects, and

• group effects.

3.4.2. The active interval

In this level of the specification the lower bound of the active interval is defined as:

The lower bound of the active interval is determined by the start time of the animation effect but may be shifted by a start delay on the animation effect.

The subsequent diagram should also refer to the animation effect start time as opposed to the animation start time.

Finally, the description of the end delay is updated to:

An end delay may also be specified but is primarily only of use when sequencing animations such as by using a sequence effect.

The normative description is updated as follows:

The lower bound of the active interval is defined by the combination of the animation effect’s start time and start delay.

An animation effect’s start time is the moment at which the parent group, if any, has scheduled the animation effect to begin. It is expressed in inherited time.

In most cases, including the case when the animation effect has no parent group, the start time is zero. The singular exception is sequence effects which set the start times of their children as described in § 3.9.4.1 The start time of children of a sequence effect.

In addition to the start time, an animation effect also has a start delay which is an offset from the start time.

Unlike the start time which is determined by the parent group, the start delay is a property of the animation effect itself.

The lower bound of the active interval of an animation effect, expressed in inherited time space, is the sum of the start time and the start delay.

These definitions are incorporated in the calculation of the local time (see § 3.4.3 Local time and inherited time) and active time.

And finally regarding the definition of the end time:

The end time of an animation effect is the result of evaluating max(start time + start delay + active duration + end delay, 0).

3.4.3. Local time and inherited time

This section is added.

In Web Animations all times are relative to some point of reference. These different points of reference produce different time spaces.

This can be compared to coordinate spaces as used in computer graphics. The zero time of a time space is analogous to the origin of a coordinate space.

Just as with coordinate spaces, time spaces can also be nested. Group effects typically perform some transformations on the time values they receive from their parent or animation before passing on the transformed time values to their children. Child animation effects then operate within that transformed time space.

Children take the transformed time values from their parent—called the inherited time—and add their start time to establish their own local time space as illustrated below.

For an animation effect, the inherited time at a given moment is based on the first matching condition from the following:

The local time of an animation effect is the animation effect’s inherited time minus its start time. If the inherited time is unresolved then the local time is also unresolved.

3.4.4. Animation effect phases and states

The normative definition of in play includes the following condition:

2. the animation effect has a parent group that is in play or else the animation effect is directly associated with an animation that is not finished.

In place of:

2. the animation effect is associated with an animation that is not finished.

The normative definition of current adds the following condition:

• the animation effect has a parent group and the parent group is current.

Add the following definitions to the list used in determining the phase of an animation effect.

at progress timeline boundary

Determined using the following procedure:

1. If any of the following conditions are true:

   • the associated animation’s timeline is not a progress-based timeline, or

   • the associated animation’s timeline duration is unresolved or zero, or

   • the animation’s playback rate is zero

   return false

1. Let effective start time be the animation’s start time if resolved, or zero otherwise.

   1. Set unlimited current time based on the first matching condition:

      start time is resolved:

      (timeline time - start time) × playback rate

      Otherwise

      animation’s current time

   2. Let effective timeline time be unlimited current time / animation’s playback rate + effective start time

   3. Let effective timeline progress be effective timeline time / timeline duration

   4. If effective timeline progress is 0 or 1, return true, otherwise false.

This procedure is not strictly correct for a paused animation if the animation’s current time is explicitly set, as this can introduce a lead or lag, between the timeline’s current time and animation’s current time.

This procedure can likely be simplified, and instead determine if at a scrolling boundary regardless of playback rate or start time. The surprising behavior that this is trying to prevent is an animation becoming inactive precisely at the scroll limit, alleviating the need for set a fill-mode with a ScrollTimeline. Checking if timeline current time is 0 or timeline duration may be sufficient.

Replace:

An animation effect is in the before phase if the animation effect’s local time is not unresolved and either of the following conditions are met:

1. the local time is less than the before-active boundary time, or

2. the animation direction is "backwards" and the local time is equal to the before-active boundary time.

with:

An animation effect is in the before phase if the animation effect’s local time is not unresolved and either of the following conditions are met:

1. the local time is less than the before-active boundary time, or

2. the animation direction is "backwards" and the local time is equal to the before-active boundary time and not at progress timeline boundary.

Replace:

An animation effect is in the after phase if the animation effect’s local time is not unresolved and either of the following conditions are met:

1. the local time is greater than the active-after boundary time, or

2. the animation direction is "forwards" and the local time is equal to the active-after boundary time.

with:

An animation effect is in the after phase if the animation effect’s local time is not unresolved and either of the following conditions are met:

1. the local time is greater than the active-after boundary time, or

2. the animation direction is "forwards" and the local time is equal to the active-after boundary time and not at progress timeline boundary.

3.4.5. Fill modes

3.5. Repeating

3.5.1. Iteration intervals

After:

The length of a single iteration is called the iteration duration.

Add:

The initial iteration duration of an animation effect is simply its intrinsic iteration duration. The intrinsic iteration duration is calculated from the first matching condition from below:

If the animation effect is a group effect,

Follow the procedure in § 3.9.3 The intrinsic iteration duration of a group effect

If the animation effect is a sequence effect,

Follow the procedure in § 3.9.4.2 The intrinsic iteration duration of a sequence effect

If timeline duration is unresolved or iteration count is zero,

Return 0

Otherwise

Return (100% - start delay - end delay) / iteration count

Note: Presently start and end delays are zero until such time as percentage based delays are supported.

The iteration duration of an animation effect may be set by the author to represent a value other than the intrinsic iteration duration.

3.5.2. Iteration time space

3.5.3. Interval timing

This section is non-normative

The description is updated as follows:

In the examples below, for the repeated effect, at local time 1s, the iteration time is 0. For the sequenced effects, at inherited time 1s, only effect B will be in play; there is no overlap.

And likewise the figure is updated as follows:

3.6. Animation effect speed control

(This section is added.)

Like animations, animation effects also have a playback rate parameter. The playback rate of an animation effect is a finite real number that acts as a multiplier when calculating the animation effect’s transformed time from its local time.

The effect of setting the playback rate of an animation effect differs from the setting the playback rate on an animation. Its behavior is defined in the timing calculations given in § 3.7 Core animation effect calculations.

3.7. Core animation effect calculations

3.7.1. Overview

This section is non-normative

Update description from:

At the core of the Web Animations timing model is the process that takes a local time value and converts it to an iteration progress.

to:

At the core of the Web Animations timing model is the process that takes an inherited time value and converts it to an iteration progress.

Update diagram to show animation effect playback rate:

Update:

Having established the active duration, the process for transforming an animation effect’s local time into its transformed progress (iteration progress) is illustrated below.

to:

Having established the active duration, the process for transforming an animation effect’s inherited time into its transformed progress (iteration progress) is illustrated below.

Update the time calculations diagram as follows:

Update:

The first step, calculating the local time is described in Local time.

to:

The first step, calculating the local time is described in § 3.4.3 Local time and inherited time.

3.7.2. Calculating the active duration

Updated to:

In order to calculate the active duration we first define the repeated duration as follows:

repeated duration = iteration duration × iteration count

If either the iteration duration or iteration count are zero, the repeated duration is zero.

This clarification is needed since the result of infinity multiplied by zero is undefined according to IEEE 754-2008.

The active duration is calculated according to the following steps:

1. If the playback rate is zero, return Infinity.

2. Otherwise, return repeated duration / abs(playback rate).

3.7.3. Transforming the local time

3.7.3.1. Calculating the active time

Update the qualification on the definition of the active time to include reference to the parent group:

However, it is only defined when the animation effect should produce an output and hence depends on its fill mode and phase as well as the phase of its parent group, if any, as follows,

Update the definition to include the additional steps to for each phase:

If the animation effect is in the before phase,

The result depends on the first matching condition from the following,

If the animation effect has a parent group and that parent group is in the after phase,

Return an unresolved time value.

…

If the animation effect is in the active phase,

The result depends on the first matching condition from the following,

If the animation effect has a parent group and that parent group is in the before phase, and the fill mode of this animation effect is none or forwards,

Return an unresolved time value.

If the animation effect has a parent group and that parent group is in the after phase, and the fill mode of this animation effect is none or backwards,

Return an unresolved time value.

Otherwise,

Return the result of evaluating local time - start delay.

If the animation effect is in the after phase,

The result depends on the first matching condition from the following,

If the animation effect has a parent group and that parent group is in the before phase,

Return an unresolved time value.

…

Otherwise (the local time is unresolved),

Return an unresolved time value.

3.7.3.2. Calculating the overall progress

In the definition of the overall progress update the “Otherwise” branch of the definition of the initial progress as:

Otherwise,

Calculate the overall progress following the first matching condition from below:

If the playback rate is less than zero,

Let overall progress be (active time - active duration) × playback rate / iteration duration.

If the playback rate is zero,

Let overall progress be zero.

Otherwise,

Let overall progress be (active time × playback rate) / iteration duration.

3.8. Time transformations

3.8.1. Calculating the transformed progress

Replace the second step as the calculation of the before flag (to accommodate the effect playback rate):

1. If either the current direction is forwards or the playback rate ≥ 0 (but not when both conditions are true), let going forwards be true, otherwise it is false.

3.8.2. Calculating the transformed time

(This section is added.)

The transformed time of an animation effect is simply the transformed progress multiplied by the iteration duration.

If the transformed progress is unresolved, then the transformed time is also unresolved.

If the transformed progress is zero and the iteration duration is infinity, then the transformed time is zero.

3.9. Grouping and synchronization

This section is non-normative

While it is possible to set the timing properties of animation effects individually, it is often useful to synchronize animation effects so that they share common timing properties and maintain their temporal relationship. This is achieved using an group effect.

A simple example is illustrated below.

When a group effect is directly associated with an animation, the animation effect associated with the group effect can be seeked, paused, and stopped as a unit.

A group effect is a type of animation effect that contains an ordered sequence of zero or more animation effects known as child effects.

At a given moment, an animation effect may be a child effect of at most one group effect known as the parent group. The parent group cannot be the same animation effect as the child effect itself.

By nesting group effects it is possible to create hierarchical tree structures. The following terms are used to describe the parts and properties of such structures and are defined in [DOM]:

• tree order

• root

• ancestor

• descendant

• inclusive ancestor

• inclusive descendant

• next sibling

• previous sibling

• first child

• last child

Note: in applying these definitions to animation effects, the term parent refers exclusively to a parent group and does not include the animation which with an animation effect may be directly associated despite the fact that conceptually the animation acts as a parent time source.

The temporal relationship between a child effect and its parent group is incorporated in the definition of inherited time (see § 3.4.3 Local time and inherited time).

3.9.1. Relationship of group time to child time

This section is non-normative

The timing of the children of a group effect is based on the timing of the group. Specifically, times for the children are based on the parent’s transformed time. With regards to repetition, this means the children operate inside an iteration of the parent.

For example, if a group effect has an iteration count of 2, then the children of the group will all play twice since they effectively play inside the group’s iterations.

Note that even in this case, the child animation effects still have only one active interval. However, as a result of the parent’s timing, the active interval is played twice.

If an iteration count is specified for the children of a group as well as for the group itself, the effect is as if the iteration count of the group was multiplied with the iteration count of the children.

A further result of the children of a group effect basing their timing on the group’s transformed time is that they cannot animate outside of the group’s active interval. This is because the transformed time of a group will not change outside its active interval. This allows groups to clip the playback of their children.

Some further consequences of group effect children basing their timing on their parent group’s transformed time are:

• Setting the playback rate of a group effect will speed up or slow down all children.

• Changing the playback direction of a group effect will change the direction of all children.

• Applying a timing function to a group effect will affect the progress of all children.

3.9.2. The start time of children of a group effect

The start time of a child effect of a group effect is zero.

Note that specific types of group effects may override this definition to provide other kinds of synchronization behavior.

3.9.3. The intrinsic iteration duration of a group effect

The intrinsic iteration duration of a group effect is based on the time when the last child effect completes its active interval and depends on the number of child effects as follows.

If the group has no child effects,

the intrinsic iteration duration is zero.

Otherwise,

1. Let maximum end time be the maximum value after calculating the end time of each child effect in the group. The end time may be expressed as a time or a percentage (in the case of a progress-based timeline). In the event of mixed time and percentage end times, the largest time based value equates to 100% for the purpose of time scaling.

2. The intrinsic iteration duration is the result of evaluating max(0, maximum end time).

This definition of the intrinsic iteration duration may be overridden by specific types of group effects.

3.9.4. Sequence effects

This section is non-normative

Specific types of group effects can be used to provide different kinds of synchronization behavior for their children. This specification defines one additional type of group effect: a sequence effect. Sequence effects arrange the start times of their children so that they run one at a time, in turn.

Compare the two arrangements illustrated below:

Since group effects can also contain other group effects, complex synchronization is possible by combining different types of groups as illustrated below.

A sequence effect is a type of group effect that schedules its child effects such that they play in turn following their order in the group. This sequencing is achieved by adjusting the start time of each child effect in the group.

3.9.4.1. The start time of children of a sequence effect

The start time of a child effect of a sequence effect is the end time of the child’s previous sibling. If the child has no previous sibling the start time is zero.

This section is non-normative

Because the start of the active interval is based on the sum of an animation effect’s start time and start delay, the active intervals of children of a sequence effect need not run in strict sequence but can be shifted back and forth by using the start delay as shown in the following diagram.

A negative start delay can be used to cause the active interval of two children to overlap. Note that the start delay affects the start time of subsequent children in the group.

3.9.4.2. The intrinsic iteration duration of a sequence effect

The intrinsic iteration duration of a sequence effect is equivalent to the start time of a hypothetical child effect appended to the group’s children calculated according to the definition in § 3.9.4.1 The start time of children of a sequence effect unless that produces a negative value, in which case the intrinsic iteration duration is zero.

As a result, if the sequence effect has no child effects the intrinsic iteration duration will be zero.

4. Animation model

4.1. Animation types

4.1.1. Not animatable

Update the description of an effect that targets a non-animated property as:

An animation effect that targets a property that is not animatable will still exhibit the usual behavior for an animation effect such as occupying time in a sequence effect and delaying the fulfillment of an animation’s current finished promise.

4.2. Keyframe Effects

4.2.1. The effect value of a keyframe effect

The procedure for computing the effect value of a single property referenced by a keyframe effect as one of its target properties, for a given iteration progress, current iteration and underlying value is amended by inserting the following step after the step to apply the keyframe effect composite mode.

12. For each keyframe in interval endpoints:

    1. (As in web-animations-1).

    2. If this keyframe effect has an iteration composite operation of accumulate, apply the following step current iteration times:

       • replace the property value of target property on keyframe with the result of combining the property value on the final keyframe in property-specific keyframes (V_a) with the property value on keyframe (V_b) using the accumulation procedure defined for target property.

       Note: The order of arguments here is important. In the case where the animation type of the target property does not define a procedure for accumulation or addition, the default definition for these procedures result in V_b being returned. When performing iteration composition on properties that do not support accumulation, the result should be the initial property value of target property on keyframe, hence we make this V_b in the above step.

4.3. Combining effects

4.3.1. The effect stack

The procedure for sorting effects appends the following step:

1. Sort A and B in tree order. (By this point, A and B must have the same animation since otherwise the order would have been resolved in the previous step.)

4.4. Effect accumulation

Similar to the compositing performed between effect values (see Web Animations § 5.4.4 Effect composition), the iteration composite operation determines how values are combined between successive iterations of the same keyframe effect.

This specification defines two iteration composite operations as follows:

replace

Each successive iteration is calculated independently of previous iterations.

accumulate

Successive iterations of the animation are accumulated with the final value of the previous iteration.

The application of the iteration composite operation is incorporated in the calculation of the effect value in § 4.2.1 The effect value of a keyframe effect.

5. Programming interface

5.1. The AnimationTimeline interface

[Exposed=Window]
partial interface AnimationTimeline {
    readonly attribute CSSNumberish? currentTime;
    readonly attribute CSSNumberish? duration;
    Animation play (optional AnimationEffect? effect = null);
};

5.2. The Animation interface

Update the startTime and currentTime of the Animation interface as follows:

[Exposed=Window]
partial interface Animation {
    attribute CSSNumberish?       startTime;
    attribute CSSNumberish?       currentTime;
};

Replace start time and current time attribute descriptions with:

5.3. The AnimationEffect interface

[Exposed=Window]
partial interface AnimationEffect {
    // Timing hierarchy
    readonly attribute GroupEffect?     parent;
    readonly attribute AnimationEffect? previousSibling;
    readonly attribute AnimationEffect? nextSibling;

    undefined before (AnimationEffect... effects);
    undefined after (AnimationEffect... effects);
    undefined replace (AnimationEffect... effects);
    undefined remove ();
};

The remove() method can be used to remove an effect from either its parent group or animation. Should we keep it in level 1 and define it simply as removing the animation from its animation?

5.4. The EffectTiming and OptionalEffectTiming dictionaries

partial dictionary EffectTiming {
    double delay;
    double endDelay;
    double playbackRate = 1.0;
    (unrestricted double or CSSNumericValue or DOMString) duration = "auto";
};

partial dictionary OptionalEffectTiming {
    double playbackRate;
};

Note: In this version of the spec, duration is not settable as a CSSNumericValue; however, duration may be returned as a CSSNumericValue when resolving the duration in getComputedTiming(). Future versions of the spec may enable setting the duration as a CSSNumeric value, where the unit is a valid time unit or percent.

5.5. Updating the timing of an AnimationEffect

Replace:

Assign each member that exists in input to the corresponding timing property of effect as follows:

• delay → start delay

• endDelay → end delay

• fill → fill mode

• iterationStart → iteration start

• iterations → iteration count

• duration → iteration duration

• direction → playback direction

• easing → timing function

with:

Assign each member that exists in input to the corresponding timing property of effect as follows:

• delay → specified start delay

• endDelay → specified end delay

• fill → fill mode

• iterationStart → iteration start

• iterations → iteration count

• duration → specified iteration duration

• direction → playback direction

• easing → timing function

Add:

Follow the procedure to normalize specified timing.

Timing properties may also be updated due to a style change. Any change to a CSS animation property that affects timing requres rerunning the procedure to normalize specified timing.

5.6. The ComputedEffectTiming dictionary

partial dictionary ComputedEffectTiming {
    CSSNumberish         startTime;
    CSSNumberish         endTime;
    CSSNumberish         activeDuration;
    CSSNumberish?        localTime;
};

5.6.1. The FillMode enumeration

enum FillMode { "none", "forwards", "backwards", "both", "auto" };

auto

Update the description as:

Fill backwards and forwards when applied to an GroupEffect and no fill when applied to an KeyframeEffect.

5.7. The GroupEffect interface

(This section is added.)

Group effects are represented by the GroupEffect interface.

[Exposed=Window]
interface GroupEffect {
  constructor(sequence<AnimationEffect>? children,
              optional (unrestricted double or EffectTiming) timing = {});

  readonly attribute AnimationNodeList  children;
  readonly attribute AnimationEffect?   firstChild;
  readonly attribute AnimationEffect?   lastChild;
  GroupEffect clone ();

  undefined prepend (AnimationEffect... effects);
  undefined append (AnimationEffect... effects);
};

5.7.1. Processing a timing argument

The timing parameter passed to the GroupEffect() or SequenceEffect() constructor may be an EffectTiming object, a double representing the duration of the animation effect in milliseconds, or undefined.

The following procedure to process a timing argument, timing, normalizes the above inputs into a EffectTiming object.

If timing is an EffectTiming object,

Return timing.

If timing is a double,

Return a new EffectTiming object with all members set to their default values and duration set to timing.

Otherwise (timing is undefined),

Return a new EffectTiming object with all members set to their default values.

5.7.2. Definitions for manipulating hierarchies

The next sibling of effect not included in a set of animation effects, effects is determined using the following steps:

1. Let context effect be effect.

2. While the next sibling of context effect is not null perform the following steps:

   1. Let context effect be the next sibling of context effect.

   2. If context effect is not in effects return context effect and abort these steps.

3. Return null.

To remove a effect from its parent group or animation, perform the steps corresponding to the first matching condition from below, if any:

If effect has a parent group,

Remove effect from the parent group’s list of child effects.

If effect is directly associated with an animation,

Disassociate effect from the animation.

To insert a series of zero or more animation effects, effects, to parent’s list of child effects before reference child perform the following steps for each effect in effects:

1. Remove effect from its parent.

2. Insert effect to parent’s list of child effects before reference child

5.8. The AnimationNodeList interface

A list of animation effects may be represented by an AnimationNodeList.

The AnimationNodeList interface supports indexed properties with indices in the range 0 ≤ index < length.

The only reason this interface exists is to provide a familiar experience for authors familiar with DOM interfaces where child nodes are accessed via a children member.

[Exposed=Window]
interface AnimationNodeList {
    readonly attribute unsigned long length;
    getter AnimationEffect? item (unsigned long index);
};

5.9. The SequenceEffect interfaces

Sequence effects are represented by the SequenceEffect interface.

[Exposed=Window]
interface SequenceEffect : GroupEffect {
  constructor(sequence<AnimationEffect>? children,
              optional (unrestricted double or EffectTiming) timing = {});

  SequenceEffect clone ();
};

5.10. The KeyframeEffect interfaces

The KeyframeEffect interface is modified to add the following:

partial interface KeyframeEffect {
    attribute IterationCompositeOperation    iterationComposite;
};

new SequenceEffect(
  [
    new KeyframeEffect(elem, { opacity: 0 }, 1000),
    new KeyframeEffect(elem, { visibility: 'hidden' }, { fill: 'forwards' })
  ]
);

partial dictionary KeyframeEffectOptions {
    IterationCompositeOperation iterationComposite = "replace";
};

enum IterationCompositeOperation { "replace", "accumulate" };

callback EffectCallback = undefined (double? progress,
                                (Element or CSSPseudoElement) currentTarget,
                                Animation animation);

[Exposed=Window]
interface AnimationPlaybackEvent : Event {
    constructor(DOMString type, optional AnimationPlaybackEventInit
    eventInitDict = {});
    readonly attribute CSSNumberish? currentTime;
    readonly attribute CSSNumberish? timelineTime;
};
dictionary AnimationPlaybackEventInit : EventInit {
    CSSNumberish? currentTime = null;
    CSSNumberish? timelineTime = null;
};