@hua-labs/motion-core 2.3.0 → 2.4.0

package/dist/chunk-LSIP7MB5.cjs

@@ -0,0 +1,1090 @@
+'use strict';
+
+var react = require('react');
+
+// src/core/MotionEngine.ts
+var MotionEngine = class {
+  constructor() {
+    this.motions = /* @__PURE__ */ new Map();
+    this.isRunning = false;
+    this.animationFrameId = null;
+  }
+  /**
+   * 모션 시작
+   */
+  motion(element, motionFrames, options) {
+    return new Promise((resolve) => {
+      const motionId = this.generateMotionId();
+      this.enableGPUAcceleration(element);
+      this.createLayer(element);
+      const motion = {
+        id: motionId,
+        element,
+        isRunning: true,
+        isPaused: false,
+        currentProgress: 0,
+        startTime: Date.now() + (options.delay || 0),
+        pauseTime: 0,
+        options: {
+          ...options,
+          onComplete: () => {
+            options.onComplete?.();
+            this.motions.delete(motionId);
+          }
+        }
+      };
+      this.motions.set(motionId, motion);
+      if (!this.isRunning) {
+        this.startAnimationLoop();
+      }
+      options.onStart?.();
+      resolve(motionId);
+    });
+  }
+  /**
+   * 모션 중지
+   */
+  stop(motionId) {
+    const motion = this.motions.get(motionId);
+    if (motion) {
+      motion.isRunning = false;
+      motion.options.onCancel?.();
+      this.motions.delete(motionId);
+    }
+  }
+  /**
+   * 모션 일시정지
+   */
+  pause(motionId) {
+    const motion = this.motions.get(motionId);
+    if (motion && motion.isRunning && !motion.isPaused) {
+      motion.isPaused = true;
+      motion.pauseTime = Date.now();
+    }
+  }
+  /**
+   * 모션 재개
+   */
+  resume(motionId) {
+    const motion = this.motions.get(motionId);
+    if (motion && motion.isPaused) {
+      motion.isPaused = false;
+      if (motion.pauseTime > 0) {
+        motion.startTime += Date.now() - motion.pauseTime;
+      }
+    }
+  }
+  /**
+   * 모든 모션 중지
+   */
+  stopAll() {
+    this.motions.forEach((motion) => {
+      motion.isRunning = false;
+      motion.options.onCancel?.();
+    });
+    this.motions.clear();
+    this.stopAnimationLoop();
+  }
+  /**
+   * 모션 상태 확인
+   */
+  getMotion(motionId) {
+    return this.motions.get(motionId);
+  }
+  /**
+   * 실행 중인 모션 수
+   */
+  getActiveMotionCount() {
+    return this.motions.size;
+  }
+  /**
+   * 애니메이션 루프 시작
+   */
+  startAnimationLoop() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.animate();
+  }
+  /**
+   * 애니메이션 루프 중지
+   */
+  stopAnimationLoop() {
+    if (this.animationFrameId) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+    this.isRunning = false;
+  }
+  /**
+   * 메인 애니메이션 루프
+   */
+  animate() {
+    if (!this.isRunning || this.motions.size === 0) {
+      this.stopAnimationLoop();
+      return;
+    }
+    const currentTime = Date.now();
+    const completedMotions = [];
+    this.motions.forEach((motion) => {
+      if (!motion.isRunning || motion.isPaused) return;
+      const elapsed = currentTime - motion.startTime;
+      if (elapsed < 0) return;
+      const progress = Math.min(elapsed / motion.options.duration, 1);
+      const easedProgress = motion.options.easing(progress);
+      motion.currentProgress = easedProgress;
+      this.applyMotionFrame(motion.element, easedProgress);
+      motion.options.onUpdate?.(easedProgress);
+      if (progress >= 1) {
+        completedMotions.push(motion.id);
+        motion.isRunning = false;
+        motion.options.onComplete?.();
+      }
+    });
+    completedMotions.forEach((id) => this.motions.delete(id));
+    this.animationFrameId = requestAnimationFrame(() => this.animate());
+  }
+  /**
+   * 모션 프레임 적용
+   */
+  applyMotionFrame(element, progress) {
+    const transforms = [];
+    if (element.style.transform) {
+      transforms.push(element.style.transform);
+    }
+    element.style.transform = transforms.join(" ");
+  }
+  /**
+   * GPU 가속 활성화
+   */
+  enableGPUAcceleration(element) {
+    element.style.willChange = "transform, opacity";
+    element.style.transform = "translateZ(0)";
+  }
+  /**
+   * 레이어 분리
+   */
+  createLayer(element) {
+    element.style.transform = "translateZ(0)";
+    element.style.backfaceVisibility = "hidden";
+  }
+  /**
+   * 고유 모션 ID 생성
+   */
+  generateMotionId() {
+    return `motion_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * 정리
+   */
+  destroy() {
+    this.stopAll();
+    this.stopAnimationLoop();
+  }
+};
+var motionEngine = new MotionEngine();
+
+// src/core/TransitionEffects.ts
+var TransitionEffects = class _TransitionEffects {
+  constructor() {
+    this.activeTransitions = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!_TransitionEffects.instance) {
+      _TransitionEffects.instance = new _TransitionEffects();
+    }
+    return _TransitionEffects.instance;
+  }
+  /**
+   * 공통 전환 실행 헬퍼
+   */
+  async executeTransition(element, options, config) {
+    const transitionId = this.generateTransitionId();
+    config.setup();
+    this.enableGPUAcceleration(element);
+    let resolveTransition;
+    const completed = new Promise((resolve) => {
+      resolveTransition = resolve;
+    });
+    const motionId = await motionEngine.motion(
+      element,
+      [
+        { progress: 0, properties: config.keyframes[0] },
+        { progress: 1, properties: config.keyframes[1] }
+      ],
+      {
+        duration: options.duration,
+        easing: options.easing || this.getDefaultEasing(),
+        delay: options.delay,
+        onStart: options.onTransitionStart,
+        onUpdate: config.onUpdate,
+        onComplete: () => {
+          config.onCleanup();
+          options.onTransitionComplete?.();
+          this.activeTransitions.delete(transitionId);
+          resolveTransition();
+        }
+      }
+    );
+    this.activeTransitions.set(transitionId, motionId);
+    return completed;
+  }
+  /**
+   * 페이드 인/아웃 전환
+   */
+  async fade(element, options) {
+    const initialOpacity = parseFloat(getComputedStyle(element).opacity) || 1;
+    const targetOpacity = options.direction === "reverse" ? 0 : 1;
+    return this.executeTransition(element, options, {
+      setup: () => {
+        if (options.direction === "reverse") {
+          element.style.opacity = initialOpacity.toString();
+        } else {
+          element.style.opacity = "0";
+        }
+      },
+      keyframes: [
+        { opacity: options.direction === "reverse" ? initialOpacity : 0 },
+        { opacity: targetOpacity }
+      ],
+      onUpdate: (progress) => {
+        const currentOpacity = options.direction === "reverse" ? initialOpacity * (1 - progress) : targetOpacity * progress;
+        element.style.opacity = currentOpacity.toString();
+      },
+      onCleanup: () => {
+      }
+    });
+  }
+  /**
+   * 슬라이드 전환
+   */
+  async slide(element, options) {
+    const distance = options.distance || 100;
+    const initialTransform = getComputedStyle(element).transform;
+    const isReverse = options.direction === "reverse";
+    return this.executeTransition(element, options, {
+      setup: () => {
+        if (!isReverse) {
+          element.style.transform = `translateX(${distance}px)`;
+        }
+      },
+      keyframes: [
+        { translateX: isReverse ? 0 : distance },
+        { translateX: isReverse ? distance : 0 }
+      ],
+      onUpdate: (progress) => {
+        const currentTranslateX = isReverse ? distance * progress : distance * (1 - progress);
+        element.style.transform = `translateX(${currentTranslateX}px)`;
+      },
+      onCleanup: () => {
+        element.style.transform = initialTransform;
+      }
+    });
+  }
+  /**
+   * 스케일 전환
+   */
+  async scale(element, options) {
+    const scaleValue = options.scale || 0.8;
+    const initialTransform = getComputedStyle(element).transform;
+    const isReverse = options.direction === "reverse";
+    return this.executeTransition(element, options, {
+      setup: () => {
+        if (!isReverse) {
+          element.style.transform = `scale(${scaleValue})`;
+        }
+      },
+      keyframes: [
+        { scale: isReverse ? 1 : scaleValue },
+        { scale: isReverse ? scaleValue : 1 }
+      ],
+      onUpdate: (progress) => {
+        const currentScale = isReverse ? 1 - (1 - scaleValue) * progress : scaleValue + (1 - scaleValue) * progress;
+        element.style.transform = `scale(${currentScale})`;
+      },
+      onCleanup: () => {
+        element.style.transform = initialTransform;
+      }
+    });
+  }
+  /**
+   * 플립 전환 (3D 회전)
+   */
+  async flip(element, options) {
+    const perspective = options.perspective || 1e3;
+    const initialTransform = getComputedStyle(element).transform;
+    const isReverse = options.direction === "reverse";
+    return this.executeTransition(element, options, {
+      setup: () => {
+        element.style.perspective = `${perspective}px`;
+        element.style.transformStyle = "preserve-3d";
+        if (!isReverse) {
+          element.style.transform = `rotateY(90deg)`;
+        }
+      },
+      keyframes: [
+        { rotateY: isReverse ? 0 : 90 },
+        { rotateY: isReverse ? 90 : 0 }
+      ],
+      onUpdate: (progress) => {
+        const currentRotateY = isReverse ? 90 * progress : 90 * (1 - progress);
+        element.style.transform = `rotateY(${currentRotateY}deg)`;
+      },
+      onCleanup: () => {
+        element.style.transform = initialTransform;
+        element.style.perspective = "";
+        element.style.transformStyle = "";
+      }
+    });
+  }
+  /**
+   * 큐브 전환 (3D 큐브 회전)
+   */
+  async cube(element, options) {
+    const perspective = options.perspective || 1200;
+    const initialTransform = getComputedStyle(element).transform;
+    const isReverse = options.direction === "reverse";
+    return this.executeTransition(element, options, {
+      setup: () => {
+        element.style.perspective = `${perspective}px`;
+        element.style.transformStyle = "preserve-3d";
+        if (!isReverse) {
+          element.style.transform = `rotateX(90deg) rotateY(45deg)`;
+        }
+      },
+      keyframes: [
+        { rotateX: isReverse ? 0 : 90, rotateY: isReverse ? 0 : 45 },
+        { rotateX: isReverse ? 90 : 0, rotateY: isReverse ? 45 : 0 }
+      ],
+      onUpdate: (progress) => {
+        const currentRotateX = isReverse ? 90 * progress : 90 * (1 - progress);
+        const currentRotateY = isReverse ? 45 * progress : 45 * (1 - progress);
+        element.style.transform = `rotateX(${currentRotateX}deg) rotateY(${currentRotateY}deg)`;
+      },
+      onCleanup: () => {
+        element.style.transform = initialTransform;
+        element.style.perspective = "";
+        element.style.transformStyle = "";
+      }
+    });
+  }
+  /**
+   * 모프 전환 (복합 변형)
+   */
+  async morph(element, options) {
+    const initialTransform = getComputedStyle(element).transform;
+    const isReverse = options.direction === "reverse";
+    return this.executeTransition(element, options, {
+      setup: () => {
+        if (!isReverse) {
+          element.style.transform = `scale(0.9) rotate(5deg)`;
+        }
+      },
+      keyframes: [
+        { scale: isReverse ? 1 : 0.9, rotate: isReverse ? 0 : 5 },
+        { scale: isReverse ? 0.9 : 1, rotate: isReverse ? 5 : 0 }
+      ],
+      onUpdate: (progress) => {
+        const currentScale = isReverse ? 1 - 0.1 * progress : 0.9 + 0.1 * progress;
+        const currentRotate = isReverse ? 5 * progress : 5 * (1 - progress);
+        element.style.transform = `scale(${currentScale}) rotate(${currentRotate}deg)`;
+      },
+      onCleanup: () => {
+        element.style.transform = initialTransform;
+      }
+    });
+  }
+  /**
+   * 전환 중지
+   */
+  stopTransition(transitionId) {
+    const motionId = this.activeTransitions.get(transitionId);
+    if (motionId) {
+      motionEngine.stop(motionId);
+      this.activeTransitions.delete(transitionId);
+    }
+  }
+  /**
+   * 모든 전환 중지
+   */
+  stopAllTransitions() {
+    this.activeTransitions.forEach((motionId) => {
+      motionEngine.stop(motionId);
+    });
+    this.activeTransitions.clear();
+  }
+  /**
+   * 활성 전환 수 확인
+   */
+  getActiveTransitionCount() {
+    return this.activeTransitions.size;
+  }
+  /**
+   * GPU 가속 활성화
+   */
+  enableGPUAcceleration(element) {
+    element.style.willChange = "transform, opacity";
+    const currentTransform = element.style.transform;
+    if (currentTransform && currentTransform !== "none" && currentTransform !== "") {
+      if (!currentTransform.includes("translateZ")) {
+        element.style.transform = `${currentTransform} translateZ(0)`;
+      }
+    } else {
+      element.style.transform = "translateZ(0)";
+    }
+  }
+  /**
+   * 기본 이징 함수
+   */
+  getDefaultEasing() {
+    return (t) => t * t * (3 - 2 * t);
+  }
+  /**
+   * 고유 전환 ID 생성
+   */
+  generateTransitionId() {
+    return `transition_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * 정리
+   */
+  destroy() {
+    this.stopAllTransitions();
+  }
+};
+var transitionEffects = TransitionEffects.getInstance();
+
+// src/presets/index.ts
+var MOTION_PRESETS = {
+  hero: {
+    entrance: "fadeIn",
+    delay: 200,
+    duration: 800,
+    hover: false,
+    click: false
+  },
+  title: {
+    entrance: "slideUp",
+    delay: 400,
+    duration: 700,
+    hover: false,
+    click: false
+  },
+  button: {
+    entrance: "scaleIn",
+    delay: 600,
+    duration: 300,
+    hover: true,
+    click: true
+  },
+  card: {
+    entrance: "slideUp",
+    delay: 800,
+    duration: 500,
+    hover: true,
+    click: false
+  },
+  text: {
+    entrance: "fadeIn",
+    delay: 200,
+    duration: 600,
+    hover: false,
+    click: false
+  },
+  image: {
+    entrance: "scaleIn",
+    delay: 400,
+    duration: 600,
+    hover: true,
+    click: false
+  }
+};
+var PAGE_MOTIONS = {
+  // 홈페이지
+  home: {
+    hero: { type: "hero" },
+    title: { type: "title" },
+    description: { type: "text" },
+    cta: { type: "button" },
+    feature1: { type: "card" },
+    feature2: { type: "card" },
+    feature3: { type: "card" }
+  },
+  // 대시보드
+  dashboard: {
+    header: { type: "hero" },
+    sidebar: { type: "card", entrance: "slideLeft" },
+    main: { type: "text", entrance: "fadeIn" },
+    card1: { type: "card" },
+    card2: { type: "card" },
+    card3: { type: "card" },
+    chart: { type: "image" }
+  },
+  // 제품 페이지
+  product: {
+    hero: { type: "hero" },
+    title: { type: "title" },
+    image: { type: "image" },
+    description: { type: "text" },
+    price: { type: "text" },
+    buyButton: { type: "button" },
+    features: { type: "card" }
+  },
+  // 블로그
+  blog: {
+    header: { type: "hero" },
+    title: { type: "title" },
+    content: { type: "text" },
+    sidebar: { type: "card", entrance: "slideRight" },
+    related1: { type: "card" },
+    related2: { type: "card" },
+    related3: { type: "card" }
+  }
+};
+function mergeWithPreset(preset, custom = {}) {
+  return {
+    ...preset,
+    ...custom
+  };
+}
+function getPagePreset(pageType) {
+  return PAGE_MOTIONS[pageType];
+}
+function getMotionPreset(type) {
+  return MOTION_PRESETS[type] || MOTION_PRESETS.text;
+}
+
+// src/managers/MotionStateManager.ts
+var MotionStateManager = class {
+  constructor() {
+    this.states = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 요소의 상태를 초기화
+   */
+  initializeElement(elementId, config) {
+    const initialState = {
+      internalVisibility: false,
+      // 초기에 숨김 상태로 시작 (스크롤 리빌용)
+      triggeredVisibility: false,
+      // Intersection Observer가 아직 트리거되지 않음
+      finalVisibility: false,
+      // 초기에 숨김 상태로 시작
+      opacity: 0,
+      // 초기에 투명 상태로 시작
+      translateY: 20,
+      // 초기에 아래로 이동된 상태로 시작
+      translateX: 0,
+      scale: 0.95,
+      // 초기에 약간 축소된 상태로 시작
+      rotation: 0,
+      isHovered: false,
+      isClicked: false,
+      isAnimating: false
+    };
+    this.states.set(elementId, initialState);
+    this.computeFinalState(elementId);
+  }
+  /**
+   * 내부 가시성 상태 업데이트 (초기화, 리셋 등)
+   */
+  setInternalVisibility(elementId, visible) {
+    const state = this.states.get(elementId);
+    if (!state) return;
+    state.internalVisibility = visible;
+    this.computeFinalState(elementId);
+    this.notifyListeners(elementId, state);
+  }
+  /**
+   * 외부 트리거 가시성 상태 업데이트 (Intersection Observer)
+   */
+  setTriggeredVisibility(elementId, visible) {
+    const state = this.states.get(elementId);
+    if (!state) return;
+    state.triggeredVisibility = visible;
+    this.computeFinalState(elementId);
+    this.notifyListeners(elementId, state);
+  }
+  /**
+   * 모션 값 업데이트
+   */
+  updateMotionValues(elementId, values) {
+    const state = this.states.get(elementId);
+    if (!state) return;
+    Object.assign(state, values);
+    this.notifyListeners(elementId, state);
+  }
+  /**
+   * 최종 상태 계산
+   */
+  computeFinalState(elementId) {
+    const state = this.states.get(elementId);
+    if (!state) return;
+    state.finalVisibility = state.internalVisibility || state.triggeredVisibility;
+    state.isAnimating = state.finalVisibility && (state.opacity < 1 || state.translateY > 0);
+  }
+  /**
+   * 현재 상태 조회
+   */
+  getState(elementId) {
+    return this.states.get(elementId);
+  }
+  /**
+   * 모든 상태 조회
+   */
+  getAllStates() {
+    return new Map(this.states);
+  }
+  /**
+   * 상태 변경 리스너 등록
+   */
+  subscribe(elementId, listener) {
+    if (!this.listeners.has(elementId)) {
+      this.listeners.set(elementId, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(elementId).add(listener);
+    return () => {
+      const listeners = this.listeners.get(elementId);
+      if (listeners) {
+        listeners.delete(listener);
+      }
+    };
+  }
+  /**
+   * 리스너들에게 상태 변경 알림
+   */
+  notifyListeners(elementId, state) {
+    const listeners = this.listeners.get(elementId);
+    if (!listeners) return;
+    listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (error) {
+        if (process.env.NODE_ENV === "development") {
+          console.error(`MotionStateManager listener error for ${elementId}:`, error);
+        }
+      }
+    });
+  }
+  /**
+   * 모든 상태 초기화
+   */
+  reset() {
+    this.states.clear();
+    this.listeners.clear();
+  }
+  /**
+   * 특정 요소 상태 초기화
+   */
+  resetElement(elementId) {
+    this.states.delete(elementId);
+    this.listeners.delete(elementId);
+  }
+  /**
+   * 디버그용 상태 출력
+   */
+  debug() {
+    if (process.env.NODE_ENV === "development") {
+      console.log("MotionStateManager Debug:");
+      this.states.forEach((state, elementId) => {
+        console.log(`  ${elementId}:`, {
+          internalVisibility: state.internalVisibility,
+          triggeredVisibility: state.triggeredVisibility,
+          finalVisibility: state.finalVisibility,
+          opacity: state.opacity,
+          translateY: state.translateY,
+          isAnimating: state.isAnimating
+        });
+      });
+    }
+  }
+};
+var motionStateManager = new MotionStateManager();
+
+// src/profiles/neutral.ts
+var neutral = {
+  name: "neutral",
+  base: {
+    duration: 700,
+    easing: "ease-out",
+    threshold: 0.1,
+    triggerOnce: true
+  },
+  entrance: {
+    slide: {
+      distance: 32,
+      easing: "ease-out"
+    },
+    fade: {
+      initialOpacity: 0
+    },
+    scale: {
+      from: 0.95
+    },
+    bounce: {
+      intensity: 0.3,
+      easing: "cubic-bezier(0.34, 1.56, 0.64, 1)"
+    }
+  },
+  stagger: {
+    perItem: 100,
+    baseDelay: 0
+  },
+  interaction: {
+    hover: {
+      scale: 1.05,
+      y: -2,
+      duration: 200,
+      easing: "ease-out"
+    }
+  },
+  spring: {
+    mass: 1,
+    stiffness: 100,
+    damping: 10,
+    restDelta: 0.01,
+    restSpeed: 0.01
+  },
+  reducedMotion: "fade-only"
+};
+
+// src/profiles/hua.ts
+var hua = {
+  name: "hua",
+  base: {
+    duration: 640,
+    easing: "cubic-bezier(0.22, 0.68, 0.35, 1.10)",
+    threshold: 0.12,
+    triggerOnce: true
+  },
+  entrance: {
+    slide: {
+      distance: 28,
+      easing: "cubic-bezier(0.22, 0.68, 0.35, 1.14)"
+    },
+    fade: {
+      initialOpacity: 0
+    },
+    scale: {
+      from: 0.97
+    },
+    bounce: {
+      intensity: 0.2,
+      easing: "cubic-bezier(0.22, 0.68, 0.35, 1.12)"
+    }
+  },
+  stagger: {
+    perItem: 80,
+    baseDelay: 0
+  },
+  interaction: {
+    hover: {
+      scale: 1.008,
+      y: -1,
+      duration: 180,
+      easing: "cubic-bezier(0.22, 0.68, 0.35, 1.10)"
+    }
+  },
+  spring: {
+    mass: 1,
+    stiffness: 180,
+    damping: 18,
+    restDelta: 5e-3,
+    restSpeed: 5e-3
+  },
+  reducedMotion: "fade-only"
+};
+var MotionProfileContext = react.createContext(neutral);
+function MotionProfileProvider({
+  profile = "neutral",
+  overrides,
+  children
+}) {
+  const resolved = react.useMemo(() => {
+    const base = resolveProfile(profile);
+    return overrides ? mergeProfileOverrides(base, overrides) : base;
+  }, [profile, overrides]);
+  return react.createElement(
+    MotionProfileContext.Provider,
+    { value: resolved },
+    children
+  );
+}
+function useMotionProfile() {
+  return react.useContext(MotionProfileContext);
+}
+
+// src/profiles/index.ts
+var PROFILES = {
+  neutral,
+  hua
+};
+function resolveProfile(profile) {
+  if (typeof profile === "string") {
+    return PROFILES[profile] ?? neutral;
+  }
+  return profile;
+}
+function mergeProfileOverrides(base, overrides) {
+  return deepMerge(
+    base,
+    overrides
+  );
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && sourceVal !== void 0 && typeof sourceVal === "object" && !Array.isArray(sourceVal) && typeof targetVal === "object" && targetVal !== null && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else if (sourceVal !== void 0) {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+
+// src/utils/easing.ts
+var linear = (t) => t;
+var easeIn = (t) => t * t;
+var easeOut = (t) => 1 - (1 - t) * (1 - t);
+var easeInOut = (t) => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+var easeInQuad = (t) => t * t;
+var easeOutQuad = (t) => 1 - (1 - t) * (1 - t);
+var easeInOutQuad = (t) => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+var easeInCubic = (t) => t * t * t;
+var easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+var easeInOutCubic = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+var easeInQuart = (t) => t * t * t * t;
+var easeOutQuart = (t) => 1 - Math.pow(1 - t, 4);
+var easeInOutQuart = (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+var easeInQuint = (t) => t * t * t * t * t;
+var easeOutQuint = (t) => 1 - Math.pow(1 - t, 5);
+var easeInOutQuint = (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 - Math.pow(-2 * t + 2, 5) / 2;
+var easeInSine = (t) => 1 - Math.cos(t * Math.PI / 2);
+var easeOutSine = (t) => Math.sin(t * Math.PI / 2);
+var easeInOutSine = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+var easeInExpo = (t) => t === 0 ? 0 : Math.pow(2, 10 * t - 10);
+var easeOutExpo = (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+var easeInOutExpo = (t) => {
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  if (t < 0.5) return Math.pow(2, 20 * t - 10) / 2;
+  return (2 - Math.pow(2, -20 * t + 10)) / 2;
+};
+var easeInCirc = (t) => 1 - Math.sqrt(1 - Math.pow(t, 2));
+var easeOutCirc = (t) => Math.sqrt(1 - Math.pow(t - 1, 2));
+var easeInOutCirc = (t) => {
+  if (t < 0.5) return (1 - Math.sqrt(1 - Math.pow(2 * t, 2))) / 2;
+  return (Math.sqrt(1 - Math.pow(-2 * t + 2, 2)) + 1) / 2;
+};
+var easeInBounce = (t) => 1 - easeOutBounce(1 - t);
+var easeOutBounce = (t) => {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (t < 1 / d1) {
+    return n1 * t * t;
+  } else if (t < 2 / d1) {
+    return n1 * (t -= 1.5 / d1) * t + 0.75;
+  } else if (t < 2.5 / d1) {
+    return n1 * (t -= 2.25 / d1) * t + 0.9375;
+  } else {
+    return n1 * (t -= 2.625 / d1) * t + 0.984375;
+  }
+};
+var easeInOutBounce = (t) => {
+  if (t < 0.5) return (1 - easeOutBounce(1 - 2 * t)) / 2;
+  return (1 + easeOutBounce(2 * t - 1)) / 2;
+};
+var easeInBack = (t) => {
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return c3 * t * t * t - c1 * t * t;
+};
+var easeOutBack = (t) => {
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+};
+var easeInOutBack = (t) => {
+  const c1 = 1.70158;
+  const c2 = c1 * 1.525;
+  if (t < 0.5) {
+    return Math.pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2) / 2;
+  } else {
+    return (Math.pow(2 * t - 2, 2) * ((c2 + 1) * (t * 2 - 2) + c2) + 2) / 2;
+  }
+};
+var easeInElastic = (t) => {
+  const c4 = 2 * Math.PI / 3;
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 0.75) * c4);
+};
+var easeOutElastic = (t) => {
+  const c4 = 2 * Math.PI / 3;
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+};
+var easeInOutElastic = (t) => {
+  const c5 = 2 * Math.PI / 4.5;
+  if (t === 0) return 0;
+  if (t === 1) return 1;
+  if (t < 0.5) {
+    return -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c5)) / 2;
+  } else {
+    return Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c5) / 2 + 1;
+  }
+};
+var pulse = (t) => Math.sin(t * Math.PI) * 0.5 + 0.5;
+var pulseSmooth = (t) => Math.sin(t * Math.PI * 2) * 0.3 + 0.7;
+var skeletonWave = (t) => Math.sin((t - 0.5) * Math.PI * 2) * 0.5 + 0.5;
+var blink = (t) => t < 0.5 ? 1 : 0;
+var easing = {
+  linear,
+  easeIn,
+  easeOut,
+  easeInOut,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easeInCubic,
+  easeOutCubic,
+  easeInOutCubic,
+  easeInQuart,
+  easeOutQuart,
+  easeInOutQuart,
+  easeInQuint,
+  easeOutQuint,
+  easeInOutQuint,
+  easeInSine,
+  easeOutSine,
+  easeInOutSine,
+  easeInExpo,
+  easeOutExpo,
+  easeInOutExpo,
+  easeInCirc,
+  easeOutCirc,
+  easeInOutCirc,
+  easeInBounce,
+  easeOutBounce,
+  easeInOutBounce,
+  easeInBack,
+  easeOutBack,
+  easeInOutBack,
+  easeInElastic,
+  easeOutElastic,
+  easeInOutElastic,
+  pulse,
+  pulseSmooth,
+  skeletonWave,
+  blink
+};
+function isValidEasing(easingName) {
+  return easingName in easing;
+}
+function getEasing(easingName) {
+  if (typeof easingName === "function") {
+    return easingName;
+  }
+  if (typeof easingName === "string") {
+    if (easingName in easing) {
+      return easing[easingName];
+    }
+    if (easingName === "bounce") {
+      return easing.easeOutBounce;
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.warn(`[HUA Motion] Unknown easing "${easingName}", using default "easeOut".`);
+    }
+  }
+  return easeOut;
+}
+function applyEasing(t, easingName) {
+  const easingFn = getEasing(easingName);
+  return easingFn(t);
+}
+function safeApplyEasing(t, easingName) {
+  try {
+    const easingFn = getEasing(easingName);
+    return easingFn(t);
+  } catch (err) {
+    if (process.env.NODE_ENV === "development") {
+      console.error(`[HUA Motion] Failed to apply easing "${easingName}":`, err);
+    }
+    return easeOut(t);
+  }
+}
+function getAvailableEasings() {
+  return Object.keys(easing);
+}
+function isEasingFunction(value) {
+  return typeof value === "function";
+}
+var easingPresets = {
+  default: "easeOut",
+  smooth: "easeInOutCubic",
+  fast: "easeOutQuad",
+  slow: "easeInOutSine",
+  bouncy: "easeOutBounce",
+  elastic: "easeOutElastic",
+  fade: "easeInOut",
+  scale: "easeOutBack"
+};
+function getPresetEasing(preset) {
+  const easingName = easingPresets[preset];
+  return getEasing(easingName);
+}
+
+// src/utils/springPhysics.ts
+function calculateSpring(currentValue, currentVelocity, targetValue, deltaTime, config) {
+  const { stiffness, damping, mass } = config;
+  const displacement = currentValue - targetValue;
+  const springForce = -stiffness * displacement;
+  const dampingForce = -damping * currentVelocity;
+  const acceleration = (springForce + dampingForce) / mass;
+  const newVelocity = currentVelocity + acceleration * deltaTime;
+  const newValue = currentValue + newVelocity * deltaTime;
+  return { value: newValue, velocity: newVelocity };
+}
+
+exports.MOTION_PRESETS = MOTION_PRESETS;
+exports.MotionEngine = MotionEngine;
+exports.MotionProfileProvider = MotionProfileProvider;
+exports.MotionStateManager = MotionStateManager;
+exports.PAGE_MOTIONS = PAGE_MOTIONS;
+exports.TransitionEffects = TransitionEffects;
+exports.applyEasing = applyEasing;
+exports.calculateSpring = calculateSpring;
+exports.easeIn = easeIn;
+exports.easeInOut = easeInOut;
+exports.easeInOutQuad = easeInOutQuad;
+exports.easeInQuad = easeInQuad;
+exports.easeOut = easeOut;
+exports.easeOutQuad = easeOutQuad;
+exports.easingPresets = easingPresets;
+exports.getAvailableEasings = getAvailableEasings;
+exports.getEasing = getEasing;
+exports.getMotionPreset = getMotionPreset;
+exports.getPagePreset = getPagePreset;
+exports.getPresetEasing = getPresetEasing;
+exports.hua = hua;
+exports.isEasingFunction = isEasingFunction;
+exports.isValidEasing = isValidEasing;
+exports.linear = linear;
+exports.mergeProfileOverrides = mergeProfileOverrides;
+exports.mergeWithPreset = mergeWithPreset;
+exports.motionEngine = motionEngine;
+exports.motionStateManager = motionStateManager;
+exports.neutral = neutral;
+exports.resolveProfile = resolveProfile;
+exports.safeApplyEasing = safeApplyEasing;
+exports.transitionEffects = transitionEffects;
+exports.useMotionProfile = useMotionProfile;
+//# sourceMappingURL=chunk-LSIP7MB5.cjs.map
+//# sourceMappingURL=chunk-LSIP7MB5.cjs.map