{"version":3,"file":"create.mjs","sources":["../../../../src/animation/sequence/create.ts"],"sourcesContent":["import {\n    AnimationScope,\n    createGeneratorEasing,\n    defaultOffset,\n    DOMKeyframesDefinition,\n    AnimationOptions as DynamicAnimationOptions,\n    fillOffset,\n    GeneratorFactory,\n    isGenerator,\n    isMotionValue,\n    Transition,\n    UnresolvedValueKeyframe,\n    type AnyResolvedKeyframe,\n    type MotionValue,\n} from \"motion-dom\"\nimport {\n    Easing,\n    getEasingForSegment,\n    progress,\n    reverseEasing,\n    secondsToMilliseconds,\n    warning,\n} from \"motion-utils\"\nimport { resolveSubjects } from \"../animate/resolve-subjects\"\nimport {\n    AnimationSequence,\n    At,\n    ResolvedAnimationDefinitions,\n    SequenceMap,\n    SequenceInfo,\n    SequenceOptions,\n    SequenceTime,\n    ValueSequence,\n} from \"./types\"\nimport { calculateRepeatDuration } from \"./utils/calc-repeat-duration\"\nimport { calcNextTime } from \"./utils/calc-time\"\nimport { addKeyframes } from \"./utils/edit\"\nimport { normalizeTimes } from \"./utils/normalize-times\"\nimport { compareByTime } from \"./utils/sort\"\n\nconst defaultSegmentEasing = \"easeInOut\"\n\nconst MAX_REPEAT = 20\n\nexport function createAnimationsFromSequence(\n    sequence: AnimationSequence,\n    { defaultTransition = {}, ...sequenceTransition }: SequenceOptions = {},\n    scope?: AnimationScope,\n    generators?: { [key: string]: GeneratorFactory },\n    info?: SequenceInfo\n): ResolvedAnimationDefinitions {\n    const defaultDuration = defaultTransition.duration || 0.3\n    const animationDefinitions: ResolvedAnimationDefinitions = new Map()\n    const sequences = new Map<Element | MotionValue, SequenceMap>()\n    const elementCache = {}\n    const timeLabels = new Map<string, number>()\n\n    let prevTime = 0\n    let currentTime = 0\n    let totalDuration = 0\n\n    /**\n     * Build the timeline by mapping over the sequence array and converting\n     * the definitions into keyframes and offsets with absolute time values.\n     * These will later get converted into relative offsets in a second pass.\n     *\n     * Nested sequences are resolved recursively. `base` is the absolute\n     * start of the sequence being resolved, so numeric `at` values inside\n     * a nested sequence are relative to where it starts. Returns the time\n     * the sequence ends.\n     */\n    const resolveSequence = (sequence: AnimationSequence, base: number) => {\n        let sequenceEnd = base\n\n        const resolveTime = (at: SequenceTime) =>\n            typeof at === \"number\"\n                ? base + at\n                : calcNextTime(currentTime, at, prevTime, timeLabels)\n\n        for (let i = 0; i < sequence.length; i++) {\n            const segment = sequence[i]\n\n            /**\n             * If this is a timeline label, mark it and skip the rest of this iteration.\n             */\n            if (typeof segment === \"string\") {\n                timeLabels.set(segment, currentTime)\n                continue\n            } else if (!Array.isArray(segment)) {\n                const start =\n                    segment.at === undefined\n                        ? currentTime\n                        : resolveTime(segment.at)\n\n                if (\"sequence\" in segment) {\n                    /**\n                     * Resolve the nested sequence from its start. Afterwards\n                     * \"<\" points at its start and the next segment follows\n                     * its end, as if it were a single segment.\n                     */\n                    prevTime = currentTime = start\n                    currentTime = resolveSequence(segment.sequence, start)\n                    prevTime = start\n                    sequenceEnd = Math.max(sequenceEnd, currentTime)\n                } else {\n                    timeLabels.set(segment.name, start)\n                }\n                continue\n            }\n\n            let [subject, keyframes, transition = {}] = segment\n\n            /**\n             * If a relative or absolute time value has been specified we need to resolve\n             * it in relation to the currentTime.\n             */\n            if (transition.at !== undefined) {\n                currentTime = resolveTime(transition.at)\n            }\n\n            /**\n             * Keep track of the maximum duration in this definition. This will be\n             * applied to currentTime once the definition has been parsed.\n             */\n            let maxDuration = 0\n\n            const resolveValueSequence = (\n                valueKeyframes:\n                    | UnresolvedValueKeyframe\n                    | UnresolvedValueKeyframe[],\n                valueTransition: Transition | DynamicAnimationOptions,\n                valueSequence: ValueSequence,\n                elementIndex = 0,\n                numSubjects = 0\n            ) => {\n                const valueKeyframesAsList = keyframesAsList(valueKeyframes)\n                const {\n                    delay = 0,\n                    times = defaultOffset(valueKeyframesAsList),\n                    type = defaultTransition.type || \"keyframes\",\n                    repeat,\n                    repeatType,\n                    repeatDelay = 0,\n                    ...remainingTransition\n                } = valueTransition\n                let { ease = defaultTransition.ease || \"easeOut\", duration } =\n                    valueTransition\n\n                /**\n                 * Resolve stagger() if defined.\n                 */\n                const calculatedDelay =\n                    typeof delay === \"function\"\n                        ? delay(elementIndex, numSubjects)\n                        : delay\n\n                /**\n                 * If this animation should and can use a spring, generate a spring easing function.\n                 */\n                const numKeyframes = valueKeyframesAsList.length\n                const createGenerator = isGenerator(type)\n                    ? type\n                    : generators?.[type || \"keyframes\"]\n\n                if (numKeyframes <= 2 && createGenerator) {\n                    /**\n                     * As we're creating an easing function from a spring,\n                     * ideally we want to generate it using the real distance\n                     * between the two keyframes. However this isn't always\n                     * possible - in these situations we use 0-100.\n                     */\n                    let absoluteDelta = 100\n                    if (\n                        numKeyframes === 2 &&\n                        isNumberKeyframesArray(valueKeyframesAsList)\n                    ) {\n                        const delta =\n                            valueKeyframesAsList[1] - valueKeyframesAsList[0]\n                        absoluteDelta = Math.abs(delta)\n                    }\n\n                    const springTransition = {\n                        ...defaultTransition,\n                        ...remainingTransition,\n                    }\n                    if (duration !== undefined) {\n                        springTransition.duration =\n                            secondsToMilliseconds(duration)\n                    }\n\n                    const springEasing = createGeneratorEasing(\n                        springTransition,\n                        absoluteDelta,\n                        createGenerator\n                    )\n\n                    ease = springEasing.ease\n                    duration = springEasing.duration\n                }\n\n                duration ??= defaultDuration\n\n                const startTime = currentTime + calculatedDelay\n\n                /**\n                 * If there's only one time offset of 0, fill in a second with length 1\n                 */\n                if (times.length === 1 && times[0] === 0) {\n                    times[1] = 1\n                }\n\n                /**\n                 * Fill out if offset if fewer offsets than keyframes\n                 */\n                const remainder = times.length - valueKeyframesAsList.length\n                remainder > 0 && fillOffset(times, remainder)\n\n                /**\n                 * If only one value has been set, ie [1], push a null to the start of\n                 * the keyframe array. This will let us mark a keyframe at this point\n                 * that will later be hydrated with the previous value.\n                 */\n                valueKeyframesAsList.length === 1 &&\n                    valueKeyframesAsList.unshift(null)\n\n                /**\n                 * Segments can't express `repeat: Infinity` or very large\n                 * counts — they'd leave dead time after the segment or\n                 * explode the keyframe array. Ignore with a warning.\n                 */\n                if (repeat) {\n                    typeof process !== \"undefined\" &&\n                        process.env.NODE_ENV !== \"production\" &&\n                        warning(\n                            repeat < MAX_REPEAT,\n                            `Sequence segments can't repeat ${repeat} times — ignoring repeat option. Use a value below ${MAX_REPEAT} or apply repeat at the sequence level instead.`\n                        )\n                }\n\n                if (repeat && repeat < MAX_REPEAT) {\n                    /**\n                     * Express repeatDelay in units of a single iteration's duration\n                     * so it can be added to the per-iteration time offsets below\n                     * before they're normalized to 0-1.\n                     */\n                    const repeatDelayUnits =\n                        duration > 0 ? repeatDelay / duration : 0\n\n                    duration = calculateRepeatDuration(\n                        duration,\n                        repeat,\n                        repeatDelay\n                    )\n\n                    const originalKeyframes = [...valueKeyframesAsList]\n                    const originalTimes = [...times]\n                    ease = Array.isArray(ease) ? [...ease] : [ease]\n                    const originalEase = [...ease]\n\n                    /**\n                     * For reverse/mirror, alternate iterations play the segment\n                     * backwards. mirror matches JSAnimation's mirroredGenerator:\n                     * reversed keyframes, easings unchanged. reverse matches\n                     * JSAnimation's iterationProgress = 1 - p: reversed\n                     * keyframes, easing array reversed AND each function easing\n                     * mapped through reverseEasing (string easings unchanged —\n                     * they're resolved later by the keyframes engine).\n                     */\n                    const isFlipping =\n                        repeatType === \"reverse\" || repeatType === \"mirror\"\n                    let flippedKeyframes = originalKeyframes\n                    let flippedEases = originalEase\n                    if (isFlipping) {\n                        flippedKeyframes = [...originalKeyframes].reverse()\n                        if (repeatType === \"reverse\") {\n                            flippedEases = [...originalEase]\n                                .reverse()\n                                .map((e) =>\n                                    typeof e === \"function\"\n                                        ? reverseEasing(e)\n                                        : e\n                                )\n                        }\n                    }\n\n                    for (\n                        let repeatIndex = 0;\n                        repeatIndex < repeat;\n                        repeatIndex++\n                    ) {\n                        const isFlipped = isFlipping && repeatIndex % 2 === 0\n                        const iterKeyframes = isFlipped\n                            ? flippedKeyframes\n                            : originalKeyframes\n                        const iterEase = isFlipped ? flippedEases : originalEase\n                        const iterStartOffset =\n                            (repeatIndex + 1) * (1 + repeatDelayUnits)\n\n                        /**\n                         * If repeatDelay is set, hold the previous iteration's\n                         * final value through the delay by inserting a keyframe\n                         * at the moment the next iteration begins.\n                         */\n                        if (repeatDelayUnits > 0) {\n                            valueKeyframesAsList.push(\n                                valueKeyframesAsList[\n                                    valueKeyframesAsList.length - 1\n                                ]\n                            )\n                            times.push(iterStartOffset)\n                            ease.push(\"linear\")\n                        }\n\n                        valueKeyframesAsList.push(...iterKeyframes)\n\n                        for (\n                            let keyframeIndex = 0;\n                            keyframeIndex < iterKeyframes.length;\n                            keyframeIndex++\n                        ) {\n                            times.push(\n                                originalTimes[keyframeIndex] + iterStartOffset\n                            )\n                            ease.push(\n                                keyframeIndex === 0\n                                    ? \"linear\"\n                                    : getEasingForSegment(\n                                          iterEase,\n                                          keyframeIndex - 1\n                                      )\n                            )\n                        }\n                    }\n\n                    normalizeTimes(times, repeat, repeatDelayUnits)\n                }\n\n                const targetTime = startTime + duration\n\n                /**\n                 * Add keyframes, mapping offsets to absolute time.\n                 */\n                addKeyframes(\n                    valueSequence,\n                    valueKeyframesAsList,\n                    ease as Easing | Easing[],\n                    times,\n                    startTime,\n                    targetTime\n                )\n\n                maxDuration = Math.max(calculatedDelay + duration, maxDuration)\n                totalDuration = Math.max(targetTime, totalDuration)\n            }\n\n            if (isMotionValue(subject)) {\n                const subjectSequence = getSubjectSequence(subject, sequences)\n                resolveValueSequence(\n                    keyframes as AnyResolvedKeyframe,\n                    transition,\n                    getValueSequence(\"default\", subjectSequence)\n                )\n            } else {\n                const subjects = resolveSubjects(\n                    subject,\n                    keyframes as DOMKeyframesDefinition,\n                    scope,\n                    elementCache\n                )\n\n                const numSubjects = subjects.length\n\n                /**\n                 * For every element in this segment, process the defined values.\n                 */\n                for (\n                    let subjectIndex = 0;\n                    subjectIndex < numSubjects;\n                    subjectIndex++\n                ) {\n                    /**\n                     * Cast necessary, but we know these are of this type\n                     */\n                    keyframes = keyframes as DOMKeyframesDefinition\n                    transition = transition as DynamicAnimationOptions\n\n                    const thisSubject = subjects[subjectIndex]\n                    const subjectSequence = getSubjectSequence(\n                        thisSubject,\n                        sequences\n                    )\n\n                    for (const key in keyframes) {\n                        resolveValueSequence(\n                            keyframes[\n                                key as keyof typeof keyframes\n                            ] as UnresolvedValueKeyframe,\n                            getValueTransition(transition, key),\n                            getValueSequence(key, subjectSequence),\n                            subjectIndex,\n                            numSubjects\n                        )\n                    }\n                }\n            }\n\n            prevTime = currentTime\n            currentTime += maxDuration\n            sequenceEnd = Math.max(sequenceEnd, currentTime)\n        }\n\n        return sequenceEnd\n    }\n\n    resolveSequence(sequence, 0)\n\n    if (info) {\n        info.duration = totalDuration\n        info.labels = timeLabels\n    }\n\n    /**\n     * For every element and value combination create a new animation.\n     */\n    sequences.forEach((valueSequences, element) => {\n        for (const key in valueSequences) {\n            const valueSequence = valueSequences[key]\n\n            /**\n             * Arrange all the keyframes in ascending time order.\n             */\n            valueSequence.sort(compareByTime)\n\n            const keyframes: UnresolvedValueKeyframe[] = []\n            const valueOffset: number[] = []\n            const valueEasing: Easing[] = []\n\n            /**\n             * For each keyframe, translate absolute times into\n             * relative offsets based on the total duration of the timeline.\n             */\n            for (let i = 0; i < valueSequence.length; i++) {\n                const { at, value, easing } = valueSequence[i]\n                keyframes.push(value)\n                valueOffset.push(progress(0, totalDuration, at))\n                valueEasing.push(easing || \"easeOut\")\n            }\n\n            /**\n             * If the first keyframe doesn't land on offset: 0\n             * provide one by duplicating the initial keyframe. This ensures\n             * it snaps to the first keyframe when the animation starts.\n             */\n            if (valueOffset[0] !== 0) {\n                valueOffset.unshift(0)\n                keyframes.unshift(keyframes[0])\n                valueEasing.unshift(defaultSegmentEasing)\n            }\n\n            /**\n             * If the last keyframe doesn't land on offset: 1\n             * provide one with a null wildcard value. This will ensure it\n             * stays static until the end of the animation.\n             */\n            if (valueOffset[valueOffset.length - 1] !== 1) {\n                valueOffset.push(1)\n                keyframes.push(null)\n            }\n\n            if (!animationDefinitions.has(element)) {\n                animationDefinitions.set(element, {\n                    keyframes: {},\n                    transition: {},\n                })\n            }\n\n            const definition = animationDefinitions.get(element)!\n\n            definition.keyframes[key] = keyframes\n\n            /**\n             * Exclude `type` from defaultTransition since springs have been\n             * converted to duration-based easing functions in resolveValueSequence.\n             * Including `type: \"spring\"` would cause JSAnimation to error when\n             * the merged keyframes array has more than 2 keyframes.\n             */\n            const { type: _type, ...remainingDefaultTransition } =\n                defaultTransition\n            definition.transition[key] = {\n                ...remainingDefaultTransition,\n                duration: totalDuration,\n                ease: valueEasing,\n                times: valueOffset,\n                ...sequenceTransition,\n            }\n        }\n    })\n\n    return animationDefinitions\n}\n\nfunction getSubjectSequence<O extends {}>(\n    subject: Element | MotionValue | O,\n    sequences: Map<Element | MotionValue | O, SequenceMap>\n): SequenceMap {\n    !sequences.has(subject) && sequences.set(subject, {})\n    return sequences.get(subject)!\n}\n\nfunction getValueSequence(name: string, sequences: SequenceMap): ValueSequence {\n    if (!sequences[name]) sequences[name] = []\n    return sequences[name]\n}\n\nfunction keyframesAsList(\n    keyframes: UnresolvedValueKeyframe | UnresolvedValueKeyframe[]\n): UnresolvedValueKeyframe[] {\n    return Array.isArray(keyframes) ? keyframes : [keyframes]\n}\n\nexport function getValueTransition(\n    transition: DynamicAnimationOptions & At,\n    key: string\n): DynamicAnimationOptions {\n    return transition && transition[key as keyof typeof transition]\n        ? {\n              ...transition,\n              ...(transition[key as keyof typeof transition] as Transition),\n          }\n        : { ...transition }\n}\n\nconst isNumber = (keyframe: unknown) => typeof keyframe === \"number\"\nconst isNumberKeyframesArray = (\n    keyframes: UnresolvedValueKeyframe[]\n): keyframes is number[] => keyframes.every(isNumber)\n"],"names":[],"mappings":"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"}