@servicetitan/anvil2 3.14.1 → 3.15.1

package/dist/{Button-Dwh_Nd4l.js → Button-Dn6-01xl.js}

@@ -4,9 +4,9 @@ import { useContext, useState, useEffect, useMemo, memo, useId, forwardRef, useC
 import { I as Icon } from './Icon-B5zwN7GD.js';
 import { S as Spinner } from './Spinner-B7tTWcP6.js';
 import { w as warnOnce } from './warnOnce-Y9PRHcU4.js';
+import { d as isEasingArray, e as interpolate$1, V as VisualElement, f as createBox, u as useConstant, g as motionValue, M as MotionConfigContext, b as useIsomorphicLayoutEffect, j as frame, k as cancelFrame, l as collectMotionValues, r as resolveElements, n as mixNumber, o as removeItem, q as isMotionValue, s as defaultOffset, t as createGeneratorEasing, v as fillOffset, x as reverseEasing, y as isGenerator, z as secondsToMilliseconds, A as warning, B as progress, C as isSVGElement, D as isSVGSVGElement, S as SVGVisualElement, H as HTMLVisualElement, E as visualElementStore, F as animateSingleValue, G as animateTarget, I as invariant, J as spring, m as motion } from './react-ORV84FjM.js';
 import { u as usePrefersReducedMotion } from './usePrefersReducedMotion-DR9B_D6w.js';
 import { u as useTheme } from './useTheme-B4i6a3bM.js';
-import { d as isEasingArray, e as interpolate$1, u as useConstant, f as motionValue, M as MotionConfigContext, c as useIsomorphicLayoutEffect, g as frame, j as cancelFrame, k as collectMotionValues, r as resolveElements, l as mixNumber, n as removeItem, o as isMotionValue, q as defaultOffset, s as createGeneratorEasing, t as fillOffset, v as isGenerator, x as secondsToMilliseconds, y as invariant, z as progress, V as VisualElement, A as createBox, B as isSVGElement, C as isSVGSVGElement, S as SVGVisualElement, H as HTMLVisualElement, D as visualElementStore, E as animateSingleValue, F as animateTarget, G as spring, m as motion } from './proxy-DEehATlA.js';
 import { c as cx } from './index-De1g9FRV.js';
 import { s as styles } from './Button.module-BuOc7iPY.js';
 import { u as useLayoutPropsUtil } from './useLayoutPropsUtil-DjqeAJZ9.js';
@@ -18,6 +18,7 @@ const wrap = (min, max, v) => {
     return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;
 };
 
+/*#__NO_SIDE_EFFECTS__*/
 function getEasingForSegment(easing, i) {
     return isEasingArray(easing) ? easing[wrap(0, easing.length, i)] : easing;
 }
@@ -70,11 +71,10 @@ class GroupAnimation {
         return this.getAll("startTime");
     }
     get duration() {
-        let max = 0;
-        for (let i = 0; i < this.animations.length; i++) {
-            max = Math.max(max, this.animations[i].duration);
-        }
-        return max;
+        return getMax(this.animations, "duration");
+    }
+    get iterationDuration() {
+        return getMax(this.animations, "iterationDuration");
     }
     runAll(methodName) {
         this.animations.forEach((controls) => controls[methodName]());
@@ -92,6 +92,16 @@ class GroupAnimation {
         this.runAll("complete");
     }
 }
+function getMax(animations, propName) {
+    let max = 0;
+    for (let i = 0; i < animations.length; i++) {
+        const value = animations[i][propName];
+        if (value !== null && value > max) {
+            max = value;
+        }
+    }
+    return max;
+}
 
 class GroupAnimationWithThen extends GroupAnimation {
     then(onResolve, _onReject) {
@@ -110,6 +120,43 @@ function transform(...args) {
     return useImmediate ? interpolator(inputValue) : interpolator;
 }
 
+function isObjectKey(key, object) {
+    return key in object;
+}
+class ObjectVisualElement extends VisualElement {
+    constructor() {
+        super(...arguments);
+        this.type = "object";
+    }
+    readValueFromInstance(instance, key) {
+        if (isObjectKey(key, instance)) {
+            const value = instance[key];
+            if (typeof value === "string" || typeof value === "number") {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    getBaseTargetFromProps() {
+        return undefined;
+    }
+    removeValueFromRenderState(key, renderState) {
+        delete renderState.output[key];
+    }
+    measureInstanceViewportBox() {
+        return createBox();
+    }
+    build(renderState, latestValues) {
+        Object.assign(renderState.output, latestValues);
+    }
+    renderInstance(instance, { output }) {
+        Object.assign(instance, output);
+    }
+    sortInstanceNodePosition() {
+        return 0;
+    }
+}
+
 /**
  * Creates a `MotionValue` to track the state and velocity of a value.
  *
@@ -189,16 +236,44 @@ function useComputed(compute) {
     return value;
 }
 
-function useTransform(input, inputRangeOrTransformer, outputRange, options) {
+function useTransform(input, inputRangeOrTransformer, outputRangeOrMap, options) {
     if (typeof input === "function") {
         return useComputed(input);
     }
+    /**
+     * Detect if outputRangeOrMap is an output map (object with keys)
+     * rather than an output range (array).
+     */
+    const isOutputMap = outputRangeOrMap !== undefined &&
+        !Array.isArray(outputRangeOrMap) &&
+        typeof inputRangeOrTransformer !== "function";
+    if (isOutputMap) {
+        return useMapTransform(input, inputRangeOrTransformer, outputRangeOrMap, options);
+    }
+    const outputRange = outputRangeOrMap;
     const transformer = typeof inputRangeOrTransformer === "function"
         ? inputRangeOrTransformer
         : transform(inputRangeOrTransformer, outputRange, options);
-    return Array.isArray(input)
+    const result = Array.isArray(input)
         ? useListTransform(input, transformer)
         : useListTransform([input], ([latest]) => transformer(latest));
+    const inputAccelerate = !Array.isArray(input)
+        ? input.accelerate
+        : undefined;
+    if (inputAccelerate &&
+        !inputAccelerate.isTransformed &&
+        typeof inputRangeOrTransformer !== "function" &&
+        Array.isArray(outputRangeOrMap) &&
+        options?.clamp !== false) {
+        result.accelerate = {
+            ...inputAccelerate,
+            times: inputRangeOrTransformer,
+            keyframes: outputRangeOrMap,
+            isTransformed: true,
+            ...(options?.ease ? { ease: options.ease } : {}),
+        };
+    }
+    return result;
 }
 function useListTransform(values, transformer) {
     const latest = useConstant(() => []);
@@ -211,12 +286,26 @@ function useListTransform(values, transformer) {
         return transformer(latest);
     });
 }
+function useMapTransform(inputValue, inputRange, outputMap, options) {
+    /**
+     * Capture keys once to ensure hooks are called in consistent order.
+     */
+    const keys = useConstant(() => Object.keys(outputMap));
+    const output = useConstant(() => ({}));
+    for (const key of keys) {
+        output[key] = useTransform(inputValue, inputRange, outputMap[key], options);
+    }
+    return output;
+}
 
 function isDOMKeyframes(keyframes) {
     return typeof keyframes === "object" && !Array.isArray(keyframes);
 }
 
 function resolveSubjects(subject, keyframes, scope, selectorCache) {
+    if (subject == null) {
+        return [];
+    }
     if (typeof subject === "string" && isDOMKeyframes(keyframes)) {
         return resolveElements(subject, scope, selectorCache);
     }
@@ -224,15 +313,15 @@ function resolveSubjects(subject, keyframes, scope, selectorCache) {
         return Array.from(subject);
     }
     else if (Array.isArray(subject)) {
-        return subject;
+        return subject.filter((s) => s != null);
     }
     else {
         return [subject];
     }
 }
 
-function calculateRepeatDuration(duration, repeat, _repeatDelay) {
-    return duration * (repeat + 1);
+function calculateRepeatDuration(duration, repeat, repeatDelay) {
+    return duration * (repeat + 1) + repeatDelay * repeat;
 }
 
 /**
@@ -288,10 +377,14 @@ function addKeyframes(sequence, keyframes, easing, offset, startTime, endTime) {
  * if we have original times of [0, 0.5, 1] then our repeated times will
  * be [0, 0.5, 1, 1, 1.5, 2]. Loop over the times and scale them back
  * down to a 0-1 scale.
+ *
+ * `repeatDelayUnits` is the repeatDelay expressed in units of a single
+ * iteration's duration, so the total span equals `(repeat + 1) + repeat * repeatDelayUnits`.
  */
-function normalizeTimes(times, repeat) {
+function normalizeTimes(times, repeat, repeatDelayUnits = 0) {
+    const totalUnits = repeat + 1 + repeat * repeatDelayUnits;
     for (let i = 0; i < times.length; i++) {
-        times[i] = times[i] / (repeat + 1);
+        times[i] = times[i] / totalUnits;
     }
 }
 
@@ -352,7 +445,7 @@ function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...seq
         let maxDuration = 0;
         const resolveValueSequence = (valueKeyframes, valueTransition, valueSequence, elementIndex = 0, numSubjects = 0) => {
             const valueKeyframesAsList = keyframesAsList(valueKeyframes);
-            const { delay = 0, times = defaultOffset(valueKeyframesAsList), type = "keyframes", repeat, repeatType, repeatDelay = 0, ...remainingTransition } = valueTransition;
+            const { delay = 0, times = defaultOffset(valueKeyframesAsList), type = defaultTransition.type || "keyframes", repeat, repeatType, repeatDelay = 0, ...remainingTransition } = valueTransition;
             let { ease = defaultTransition.ease || "easeOut", duration } = valueTransition;
             /**
              * Resolve stagger() if defined.
@@ -380,7 +473,10 @@ function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...seq
                     const delta = valueKeyframesAsList[1] - valueKeyframesAsList[0];
                     absoluteDelta = Math.abs(delta);
                 }
-                const springTransition = { ...remainingTransition };
+                const springTransition = {
+                    ...defaultTransition,
+                    ...remainingTransition,
+                };
                 if (duration !== undefined) {
                     springTransition.duration = secondsToMilliseconds(duration);
                 }
@@ -409,25 +505,73 @@ function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...seq
             valueKeyframesAsList.length === 1 &&
                 valueKeyframesAsList.unshift(null);
             /**
-             * Handle repeat options
+             * Segments can't express `repeat: Infinity` or very large
+             * counts — they'd leave dead time after the segment or
+             * explode the keyframe array. Ignore with a warning.
              */
             if (repeat) {
-                invariant(repeat < MAX_REPEAT, "Repeat count too high, must be less than 20", "repeat-count-high");
-                duration = calculateRepeatDuration(duration, repeat);
+                warning(repeat < MAX_REPEAT, `Sequence segments can't repeat ${repeat} times — ignoring repeat option. Use a value below ${MAX_REPEAT} or apply repeat at the sequence level instead.`);
+            }
+            if (repeat && repeat < MAX_REPEAT) {
+                /**
+                 * Express repeatDelay in units of a single iteration's duration
+                 * so it can be added to the per-iteration time offsets below
+                 * before they're normalized to 0-1.
+                 */
+                const repeatDelayUnits = duration > 0 ? repeatDelay / duration : 0;
+                duration = calculateRepeatDuration(duration, repeat, repeatDelay);
                 const originalKeyframes = [...valueKeyframesAsList];
                 const originalTimes = [...times];
                 ease = Array.isArray(ease) ? [...ease] : [ease];
                 const originalEase = [...ease];
+                /**
+                 * For reverse/mirror, alternate iterations play the segment
+                 * backwards. mirror matches JSAnimation's mirroredGenerator:
+                 * reversed keyframes, easings unchanged. reverse matches
+                 * JSAnimation's iterationProgress = 1 - p: reversed
+                 * keyframes, easing array reversed AND each function easing
+                 * mapped through reverseEasing (string easings unchanged —
+                 * they're resolved later by the keyframes engine).
+                 */
+                const isFlipping = repeatType === "reverse" || repeatType === "mirror";
+                let flippedKeyframes = originalKeyframes;
+                let flippedEases = originalEase;
+                if (isFlipping) {
+                    flippedKeyframes = [...originalKeyframes].reverse();
+                    if (repeatType === "reverse") {
+                        flippedEases = [...originalEase]
+                            .reverse()
+                            .map((e) => typeof e === "function"
+                            ? reverseEasing(e)
+                            : e);
+                    }
+                }
                 for (let repeatIndex = 0; repeatIndex < repeat; repeatIndex++) {
-                    valueKeyframesAsList.push(...originalKeyframes);
-                    for (let keyframeIndex = 0; keyframeIndex < originalKeyframes.length; keyframeIndex++) {
-                        times.push(originalTimes[keyframeIndex] + (repeatIndex + 1));
+                    const isFlipped = isFlipping && repeatIndex % 2 === 0;
+                    const iterKeyframes = isFlipped
+                        ? flippedKeyframes
+                        : originalKeyframes;
+                    const iterEase = isFlipped ? flippedEases : originalEase;
+                    const iterStartOffset = (repeatIndex + 1) * (1 + repeatDelayUnits);
+                    /**
+                     * If repeatDelay is set, hold the previous iteration's
+                     * final value through the delay by inserting a keyframe
+                     * at the moment the next iteration begins.
+                     */
+                    if (repeatDelayUnits > 0) {
+                        valueKeyframesAsList.push(valueKeyframesAsList[valueKeyframesAsList.length - 1]);
+                        times.push(iterStartOffset);
+                        ease.push("linear");
+                    }
+                    valueKeyframesAsList.push(...iterKeyframes);
+                    for (let keyframeIndex = 0; keyframeIndex < iterKeyframes.length; keyframeIndex++) {
+                        times.push(originalTimes[keyframeIndex] + iterStartOffset);
                         ease.push(keyframeIndex === 0
                             ? "linear"
-                            : getEasingForSegment(originalEase, keyframeIndex - 1));
+                            : getEasingForSegment(iterEase, keyframeIndex - 1));
                     }
                 }
-                normalizeTimes(times, repeat);
+                normalizeTimes(times, repeat, repeatDelayUnits);
             }
             const targetTime = startTime + duration;
             /**
@@ -513,8 +657,15 @@ function createAnimationsFromSequence(sequence, { defaultTransition = {}, ...seq
             }
             const definition = animationDefinitions.get(element);
             definition.keyframes[key] = keyframes;
+            /**
+             * Exclude `type` from defaultTransition since springs have been
+             * converted to duration-based easing functions in resolveValueSequence.
+             * Including `type: "spring"` would cause JSAnimation to error when
+             * the merged keyframes array has more than 2 keyframes.
+             */
+            const { type: _type, ...remainingDefaultTransition } = defaultTransition;
             definition.transition[key] = {
-                ...defaultTransition,
+                ...remainingDefaultTransition,
                 duration: totalDuration,
                 ease: valueEasing,
                 times: valueOffset,
@@ -547,43 +698,6 @@ function getValueTransition(transition, key) {
 const isNumber = (keyframe) => typeof keyframe === "number";
 const isNumberKeyframesArray = (keyframes) => keyframes.every(isNumber);
 
-function isObjectKey(key, object) {
-    return key in object;
-}
-class ObjectVisualElement extends VisualElement {
-    constructor() {
-        super(...arguments);
-        this.type = "object";
-    }
-    readValueFromInstance(instance, key) {
-        if (isObjectKey(key, instance)) {
-            const value = instance[key];
-            if (typeof value === "string" || typeof value === "number") {
-                return value;
-            }
-        }
-        return undefined;
-    }
-    getBaseTargetFromProps() {
-        return undefined;
-    }
-    removeValueFromRenderState(key, renderState) {
-        delete renderState.output[key];
-    }
-    measureInstanceViewportBox() {
-        return createBox();
-    }
-    build(renderState, latestValues) {
-        Object.assign(renderState.output, latestValues);
-    }
-    renderInstance(instance, { output }) {
-        Object.assign(instance, output);
-    }
-    sortInstanceNodePosition() {
-        return 0;
-    }
-}
-
 function createDOMVisualElement(element) {
     const options = {
         presenceContext: null,
@@ -637,12 +751,15 @@ function animateSubject(subject, keyframes, options, scope) {
             : keyframes, options ? options.default || options : options));
     }
     else {
+        // Gracefully handle null/undefined subjects (e.g., from querySelector returning null)
+        if (subject == null) {
+            return animations;
+        }
         const subjects = resolveSubjects(subject, keyframes, scope);
         const numSubjects = subjects.length;
         invariant(Boolean(numSubjects), "No valid elements provided.", "no-valid-elements");
         for (let i = 0; i < numSubjects; i++) {
             const thisSubject = subjects[i];
-            invariant(thisSubject !== null, "You're trying to perform an animation on null. Ensure that selectors are correctly finding elements and refs are correctly hydrated.", "animate-null");
             const createVisualElement = thisSubject instanceof Element
                 ? createDOMVisualElement
                 : createObjectVisualElement;
@@ -666,7 +783,28 @@ function animateSubject(subject, keyframes, options, scope) {
 
 function animateSequence(sequence, options, scope) {
     const animations = [];
-    const animationDefinitions = createAnimationsFromSequence(sequence, options, scope, { spring });
+    /**
+     * Pre-process: replace function segments with MotionValue segments,
+     * subscribe callbacks immediately
+     */
+    const processedSequence = sequence.map((segment) => {
+        if (Array.isArray(segment) && typeof segment[0] === "function") {
+            const callback = segment[0];
+            const mv = motionValue(0);
+            mv.on("change", callback);
+            if (segment.length === 1) {
+                return [mv, [0, 1]];
+            }
+            else if (segment.length === 2) {
+                return [mv, [0, 1], segment[1]];
+            }
+            else {
+                return [mv, segment[1], segment[2]];
+            }
+        }
+        return segment;
+    });
+    const animationDefinitions = createAnimationsFromSequence(processedSequence, options, scope, { spring });
     animationDefinitions.forEach(({ keyframes, transition }, subject) => {
         animations.push(...animateSubject(subject, keyframes, transition));
     });
@@ -680,19 +818,44 @@ function isSequence(value) {
  * Creates an animation function that is optionally scoped
  * to a specific element.
  */
-function createScopedAnimate(scope) {
+function createScopedAnimate(options = {}) {
+    const { scope, reduceMotion, skipAnimations } = options;
     /**
      * Implementation
      */
     function scopedAnimate(subjectOrSequence, optionsOrKeyframes, options) {
         let animations = [];
+        let animationOnComplete;
+        const inherited = {};
+        if (reduceMotion !== undefined)
+            inherited.reduceMotion = reduceMotion;
+        if (skipAnimations !== undefined)
+            inherited.skipAnimations = skipAnimations;
         if (isSequence(subjectOrSequence)) {
-            animations = animateSequence(subjectOrSequence, optionsOrKeyframes, scope);
+            const { onComplete, ...sequenceOptions } = optionsOrKeyframes || {};
+            if (typeof onComplete === "function") {
+                animationOnComplete = onComplete;
+            }
+            animations = animateSequence(subjectOrSequence, { ...inherited, ...sequenceOptions }, scope);
         }
         else {
-            animations = animateSubject(subjectOrSequence, optionsOrKeyframes, options, scope);
+            // Extract top-level onComplete so it doesn't get applied per-value
+            const { onComplete, ...rest } = options || {};
+            if (typeof onComplete === "function") {
+                animationOnComplete = onComplete;
+            }
+            animations = animateSubject(subjectOrSequence, optionsOrKeyframes, { ...inherited, ...rest }, scope);
         }
         const animation = new GroupAnimationWithThen(animations);
+        if (animationOnComplete) {
+            animation.finished.then(animationOnComplete);
+        }
+        if (scope) {
+            scope.animations.push(animation);
+            animation.finished.then(() => {
+                removeItem(scope.animations, animation);
+            });
+        }
         return animation;
     }
     return scopedAnimate;
@@ -2189,4 +2352,4 @@ const Button = forwardRef(
 Button.displayName = "Button";
 
 export { AiMarkIconAnimated as A, Button as B };
-//# sourceMappingURL=Button-Dwh_Nd4l.js.map
+//# sourceMappingURL=Button-Dn6-01xl.js.map