@mks2508/mks-ui 0.5.4 → 0.5.8

package/src/react-ui/primitives/waapi/Reorder/utils/separatorCoordination.ts

@@ -1,104 +0,0 @@
-/**
- * Utility functions for separator animation coordination.
- *
- * When a token exits, determines which separators should animate:
- * 1. The exiting token's own separator (if it has one)
- * 2. If the exiting token is the last visible, the previous token's separator
- *
- * @module primitives/waapi/Reorder/utils/separatorCoordination
- */
-
-/**
- * Calculate which separator IDs should animate along with an exiting item.
- *
- * Logic:
- * - If the exiting item is NOT the last in the list, animate its own separator
- * - If the exiting item IS the last in the list, animate the previous item's separator
- *   (because the previous item will become the new last and shouldn't have a separator)
- *
- * @param exitingId - The ID of the item being removed
- * @param currentKeys - Set of all current (non-exiting) item keys
- * @param exitingIds - Set of all currently exiting item IDs
- * @param orderedKeys - Array of keys in render order
- * @returns Array of separator IDs to animate
- *
- * @example
- * ```ts
- * // Items: [A, B, C, D] with separators after A, B, C
- * // Removing C (not last):
- * calculateSeparatorCoordination('C', {'A','B','D'}, {'C'}, ['A','B','C','D'])
- * // Returns: ['C'] - animate C's separator
- *
- * // Removing D (last item):
- * calculateSeparatorCoordination('D', {'A','B','C'}, {'D'}, ['A','B','C','D'])
- * // Returns: ['C'] - animate C's separator (C becomes new last)
- * ```
- */
-export function calculateSeparatorCoordination(
-  exitingId: string,
-  currentKeys: Set<string>,
-  exitingIds: Set<string>,
-  orderedKeys: string[]
-): string[] {
-  const additionalSeparators: string[] = [];
-
-  const visibleKeys = orderedKeys.filter(
-    key => currentKeys.has(key) || exitingIds.has(key)
-  );
-
-  const indexInVisible = visibleKeys.indexOf(exitingId);
-  if (indexInVisible === -1) {
-    return additionalSeparators;
-  }
-
-  const isLastVisible = indexInVisible === visibleKeys.length - 1;
-  const isNotLastVisible = indexInVisible < visibleKeys.length - 1;
-
-  if (isNotLastVisible) {
-    additionalSeparators.push(exitingId);
-  }
-
-  if (isLastVisible && indexInVisible > 0) {
-    const previousKey = visibleKeys[indexInVisible - 1];
-    if (previousKey && !exitingIds.has(previousKey)) {
-      additionalSeparators.push(previousKey);
-    }
-  }
-
-  return additionalSeparators;
-}
-
-/**
- * Determine if a separator should be visible based on position and animation state.
- *
- * @param _tokenId - The token ID to check (unused, kept for API compatibility)
- * @param tokenIndex - Index of the token in the visible list
- * @param totalVisible - Total number of visible tokens
- * @param separatorPhase - Current animation phase of the separator
- * @returns Whether the separator should be rendered
- */
-export function shouldShowSeparator(
-  _tokenId: string,
-  tokenIndex: number,
-  totalVisible: number,
-  separatorPhase?: 'idle' | 'exit-coordinated' | 'flip-coordinated' | 'completed'
-): boolean {
-  if (tokenIndex >= totalVisible - 1) {
-    return false;
-  }
-
-  if (!separatorPhase) {
-    return true;
-  }
-
-  switch (separatorPhase) {
-    case 'idle':
-    case 'exit-coordinated':
-    case 'flip-coordinated':
-      return true;
-    case 'completed':
-      return false;
-    default:
-      return true;
-  }
-}

package/src/react-ui/primitives/waapi/SlidingNumber/SlidingNumber.styles.ts

@@ -1,14 +0,0 @@
-import { cva, type VariantProps } from 'class-variance-authority';
-import type { StyleSlots } from '@/core/types';
-
-/**
- * Style slots for SlidingNumber component
- */
-export type SlidingNumberSlot = 'root';
-
-/**
- * Base styles for SlidingNumber component
- */
-export const slidingNumberBaseStyles: StyleSlots<SlidingNumberSlot> = {
-  root: 'waapi-sliding-number',
-};

package/src/react-ui/primitives/waapi/SlidingNumber/SlidingNumber.types.ts

@@ -1,84 +0,0 @@
-/**
- * Format options for number display using Intl.NumberFormat
- */
-export interface IFormatOptions {
-  /** Number formatting style */
-  style?: 'decimal' | 'currency' | 'percent';
-  /** Currency code (required when style is 'currency') */
-  currency?: string;
-  /** Locale for formatting (e.g., 'en-US', 'es-ES') */
-  locale?: string;
-  /** Minimum fraction digits */
-  minimumFractionDigits?: number;
-  /** Maximum fraction digits */
-  maximumFractionDigits?: number;
-  /** Whether to use grouping separators */
-  useGrouping?: boolean;
-}
-
-/**
- * Props for SlidingNumber component
- *
- * Animated number transitions with format preservation using WAAPI slot-machine-style animation.
- *
- * @example
- * ```tsx
- * // Basic counter
- * <SlidingNumber value={1234} duration={700} />
- *
- * // Currency
- * <SlidingNumber
- *   value={99.99}
- *   format={{ style: 'currency', currency: 'USD' }}
- * />
- *
- * // With motion blur
- * <SlidingNumber value={500} motionBlur={true} digitHeight={60} />
- * ```
- */
-export interface ISlidingNumberProps {
-  /** The numeric value to display */
-  value: number;
-
-  /** Animation duration in milliseconds */
-  duration?: number;
-
-  /** Font size for the number display */
-  fontSize?: string;
-
-  /** Font weight for the number display */
-  fontWeight?: string;
-
-  /** Text color */
-  color?: string;
-
-  /** Height of each digit row in pixels */
-  digitHeight?: number;
-
-  /** Delay between digit animations in milliseconds */
-  stagger?: number;
-
-  /** Enable motion blur effect during animation */
-  motionBlur?: boolean;
-
-  /** Number formatting options */
-  format?: IFormatOptions;
-
-  /**
-   * Animation direction trend
-   * - 1: Always animate upward (increasing)
-   * - -1: Always animate downward (decreasing)
-   * - 0: Auto (shorter path)
-   */
-  trend?: -1 | 0 | 1;
-
-  /** Physics-based animation configuration */
-  animationConfig?: {
-    /** Overshoot amount (higher = more bounce) */
-    overshoot?: number;
-    /** Mass of the animated object */
-    mass?: number;
-    /** Spring stiffness */
-    stiffness?: number;
-  };
-}

package/src/react-ui/primitives/waapi/SlidingNumber/index.tsx

@@ -1,474 +0,0 @@
-"use client";
-
-import React, { useEffect, useRef, useMemo, useLayoutEffect } from 'react';
-import type { ISlidingNumberProps, IFormatOptions } from './SlidingNumber.types';
-import { cn } from '@/react-ui/lib/utils';
-
-/**
- * SlidingNumber - Animated number transitions with format preservation
- *
- * Uses WAAPI slot-machine-style animation with optional motion blur.
- * Supports Intl.NumberFormat for currency, percentage, and decimal formatting.
- *
- * @example
- * ```tsx
- * // Basic counter
- * <SlidingNumber value={1234} />
- *
- * // Currency with animation
- * <SlidingNumber
- *   value={99.99}
- *   format={{ style: 'currency', currency: 'USD' }}
- *   duration={700}
- * />
- *
- * // Percentage
- * <SlidingNumber
- *   value={75.5}
- *   format={{ style: 'percent' }}
- * />
- * ```
- */
-export const SlidingNumber = ({
-  value,
-  duration = 700,
-  fontSize = '3rem',
-  fontWeight = '700',
-  color = '#000',
-  digitHeight = 60,
-  stagger = 30,
-  motionBlur = true,
-  format,
-  trend = 0,
-  animationConfig,
-}: ISlidingNumberProps): React.ReactElement => {
-  const computedEasing = useMemo(() => {
-    if (animationConfig) {
-      const { overshoot = 1, stiffness = 1, mass = 1 } = animationConfig;
-      const p1 = 0.34 * stiffness;
-      const p2 = 1 + 0.56 * overshoot;
-      const p3 = 0.64 / mass;
-      return `cubic-bezier(${Math.min(p1, 1).toFixed(2)}, ${Math.min(p2, 2).toFixed(2)}, ${Math.min(p3, 1).toFixed(2)}, 1)`;
-    }
-    return 'cubic-bezier(0.34, 1.56, 0.64, 1)';
-  }, [animationConfig]);
-
-  const currentChars = useMemo(() => parseNumberToChars(value, format), [value, format]);
-  const prevKeysRef = useRef<Set<string>>(new Set());
-  const isFirstRenderRef = useRef(true);
-
-  const enteringKeys = useMemo(() => {
-    if (isFirstRenderRef.current) return new Set<string>();
-    const entering = new Set<string>();
-    currentChars.forEach((c) => {
-      if (!prevKeysRef.current.has(c.key)) {
-        entering.add(c.key);
-      }
-    });
-    return entering;
-  }, [currentChars]);
-
-  useEffect(() => {
-    isFirstRenderRef.current = false;
-    prevKeysRef.current = new Set(currentChars.map((c) => c.key));
-  }, [currentChars]);
-
-  const getDelay = (position: number) => {
-    const absPos = Math.abs(position);
-    return (absPos - 1) * stagger;
-  };
-
-  return (
-    <div
-      className={cn('waapi-sliding-number')}
-      style={{
-        display: 'inline-flex',
-        alignItems: 'center',
-        fontSize,
-        fontWeight,
-        color,
-        fontVariantNumeric: 'tabular-nums',
-        fontFamily: 'system-ui, -apple-system, sans-serif',
-        overflow: 'hidden',
-      }}
-    >
-      {currentChars.map((item) => {
-        const isEntering = enteringKeys.has(item.key);
-
-        if (item.isDigit) {
-          return (
-            <Digit
-              key={item.key}
-              digit={Number.parseInt(item.char)}
-              duration={duration}
-              digitHeight={digitHeight}
-              delay={getDelay(item.position)}
-              motionBlur={motionBlur}
-              easing={computedEasing}
-              isEntering={isEntering}
-              trend={trend}
-            />
-          );
-        }
-
-        return (
-          <Symbol key={item.key} char={item.char} isEntering={isEntering} duration={duration} easing={computedEasing} />
-        );
-      })}
-    </div>
-  );
-};
-
-SlidingNumber.displayName = 'SlidingNumber';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-interface ICharItem {
-  char: string;
-  key: string;
-  isDigit: boolean;
-  position: number;
-}
-
-interface IDigitProps {
-  digit: number;
-  duration: number;
-  digitHeight: number;
-  delay: number;
-  motionBlur: boolean;
-  easing: string;
-  isEntering: boolean;
-  trend: -1 | 0 | 1;
-}
-
-interface ISymbolProps {
-  char: string;
-  isEntering: boolean;
-  duration: number;
-  easing: string;
-}
-
-// ============================================================================
-// Utilities
-// ============================================================================
-
-function parseNumberToChars(value: number, format?: IFormatOptions): ICharItem[] {
-  const locale = format?.locale || 'en-US';
-  const options: Intl.NumberFormatOptions = {
-    style: format?.style || 'decimal',
-    minimumFractionDigits: format?.minimumFractionDigits,
-    maximumFractionDigits: format?.maximumFractionDigits,
-    useGrouping: format?.useGrouping ?? true,
-  };
-
-  if (format?.style === 'currency' && format?.currency) {
-    options.currency = format.currency;
-  }
-
-  const formatter = new Intl.NumberFormat(locale, options);
-  const parts = formatter.formatToParts(value);
-
-  const result: ICharItem[] = [];
-
-  let integerDigitCount = 0;
-  parts.forEach((part) => {
-    if (part.type === 'integer') {
-      integerDigitCount += part.value.length;
-    }
-  });
-
-  let integerIndex = integerDigitCount;
-  let fractionIndex = 0;
-  let groupCount = 0;
-
-  parts.forEach((part, partIdx) => {
-    if (part.type === 'integer') {
-      for (const char of part.value) {
-        result.push({
-          char,
-          key: `int-${integerIndex}`,
-          isDigit: true,
-          position: integerIndex,
-        });
-        integerIndex--;
-      }
-    } else if (part.type === 'fraction') {
-      for (const char of part.value) {
-        fractionIndex++;
-        result.push({
-          char,
-          key: `frac-${fractionIndex}`,
-          isDigit: true,
-          position: -fractionIndex,
-        });
-      }
-    } else if (part.type === 'decimal') {
-      result.push({ char: part.value, key: 'decimal', isDigit: false, position: 0 });
-    } else if (part.type === 'group') {
-      groupCount++;
-      result.push({ char: part.value, key: `group-${groupCount}`, isDigit: false, position: 0 });
-    } else if (part.type === 'currency') {
-      result.push({ char: part.value, key: `currency-${partIdx}`, isDigit: false, position: 0 });
-    } else if (part.type === 'percentSign') {
-      result.push({ char: part.value, key: 'percent', isDigit: false, position: 0 });
-    } else {
-      result.push({ char: part.value, key: `symbol-${partIdx}`, isDigit: false, position: 0 });
-    }
-  });
-
-  return result;
-}
-
-// ============================================================================
-// Symbol Component (non-digit characters)
-// ============================================================================
-
-function Symbol({ char, isEntering, duration, easing }: ISymbolProps) {
-  const ref = useRef<HTMLSpanElement>(null);
-  const hasAnimatedRef = useRef(false);
-
-  useLayoutEffect(() => {
-    if (!ref.current || !isEntering || hasAnimatedRef.current) return;
-    hasAnimatedRef.current = true;
-
-    ref.current.animate(
-      [
-        { opacity: 0, transform: 'scale(0.8)' },
-        { opacity: 1, transform: 'scale(1)' },
-      ],
-      {
-        duration: duration * 0.3,
-        easing,
-        fill: 'forwards',
-      }
-    );
-  }, [isEntering, duration, easing]);
-
-  return (
-    <span
-      ref={ref}
-      style={{
-        display: 'inline-block',
-        whiteSpace: 'pre',
-        opacity: isEntering ? 0 : 1,
-      }}
-    >
-      {char}
-    </span>
-  );
-}
-
-// ============================================================================
-// Digit Component (animated numbers)
-// ============================================================================
-
-function Digit({ digit, duration, digitHeight, delay, motionBlur, easing, isEntering, trend }: IDigitProps) {
-  const columnRef = useRef<HTMLDivElement>(null);
-  const containerRef = useRef<HTMLDivElement>(null);
-  const animationRef = useRef<Animation | null>(null);
-  const filterId = useRef(`blur-${Math.random().toString(36).slice(2, 9)}`).current;
-
-  const currentOffsetRef = useRef<number | null>(null);
-  const targetDigitRef = useRef(digit);
-  const hasInitializedRef = useRef(false);
-
-  const sequence = useMemo(() => {
-    const seq: number[] = [];
-    for (let cycle = -1; cycle <= 1; cycle++) {
-      for (let d = 0; d <= 9; d++) {
-        seq.push(d);
-      }
-    }
-    return seq;
-  }, []);
-
-  useLayoutEffect(() => {
-    if (!hasInitializedRef.current) {
-      hasInitializedRef.current = true;
-      const offset = -(digit + 10) * digitHeight;
-      currentOffsetRef.current = offset;
-      targetDigitRef.current = digit;
-
-      if (columnRef.current) {
-        columnRef.current.style.transform = `translateY(${offset}px)`;
-      }
-    }
-  }, [digit, digitHeight]);
-
-  useLayoutEffect(() => {
-    if (!containerRef.current || !isEntering) return;
-
-    containerRef.current.animate(
-      [
-        { opacity: 0, transform: 'scale(0.5) translateY(-20px)' },
-        { opacity: 1, transform: 'scale(1) translateY(0)' },
-      ],
-      {
-        duration: duration * 0.4,
-        easing,
-        fill: 'forwards',
-      }
-    );
-  }, [isEntering, duration, easing]);
-
-  useEffect(() => {
-    targetDigitRef.current = digit;
-
-    if (!hasInitializedRef.current) return;
-
-    const currentDigit =
-      currentOffsetRef.current !== null
-        ? (((Math.round(-currentOffsetRef.current / digitHeight) - 10) % 10) + 10) % 10
-        : digit;
-
-    if (digit === currentDigit && currentOffsetRef.current !== null) {
-      return;
-    }
-
-    animateToDigit(digit);
-  }, [digit, digitHeight]);
-
-  const animateToDigit = (target: number) => {
-    if (!columnRef.current || !containerRef.current) return;
-
-    if (animationRef.current) {
-      const computedStyle = getComputedStyle(columnRef.current);
-      const matrix = new DOMMatrix(computedStyle.transform);
-      currentOffsetRef.current = matrix.m42;
-      animationRef.current.cancel();
-      animationRef.current = null;
-      columnRef.current.style.transform = `translateY(${currentOffsetRef.current}px)`;
-    }
-
-    const rawIndex = currentOffsetRef.current !== null ? -currentOffsetRef.current / digitHeight : target + 10;
-
-    const currentDigitFromOffset = (((Math.round(rawIndex) - 10) % 10) + 10) % 10;
-    const from = currentDigitFromOffset;
-
-    if (target === from && currentOffsetRef.current !== null) {
-      const normalizedOffset = -(target + 10) * digitHeight;
-      if (columnRef.current) {
-        const currentAnim = animationRef.current as Animation | null;
-        if (currentAnim) {
-          currentAnim.cancel();
-        }
-        columnRef.current.style.transform = `translateY(${normalizedOffset}px)`;
-      }
-      currentOffsetRef.current = normalizedOffset;
-      return;
-    }
-
-    let diff: number;
-    if (trend === 1) {
-      diff = target >= from ? target - from : 10 - from + target;
-    } else if (trend === -1) {
-      diff = target <= from ? target - from : target - from - 10;
-    } else {
-      diff = target - from;
-      if (diff > 5) diff -= 10;
-      else if (diff < -5) diff += 10;
-    }
-
-    const startOffset = currentOffsetRef.current ?? -(from + 10) * digitHeight;
-    const endOffset = startOffset - diff * digitHeight;
-
-    const blurEl = document.getElementById(filterId)?.querySelector('feGaussianBlur');
-    if (motionBlur && blurEl) {
-      const intensity = Math.min(Math.abs(diff) * 1.2, 6);
-      blurEl.setAttribute('stdDeviation', `0,${intensity}`);
-      containerRef.current.style.filter = `url(#${filterId})`;
-    }
-
-    const anim = columnRef.current.animate(
-      [{ transform: `translateY(${startOffset}px)` }, { transform: `translateY(${endOffset}px)` }],
-      {
-        duration,
-        delay,
-        easing,
-        fill: 'forwards',
-      }
-    );
-
-    animationRef.current = anim;
-
-    anim.onfinish = () => {
-      const normalizedOffset = -(target + 10) * digitHeight;
-      if (columnRef.current) {
-        anim.cancel();
-        columnRef.current.style.transform = `translateY(${normalizedOffset}px)`;
-      }
-      currentOffsetRef.current = normalizedOffset;
-
-      if (containerRef.current) {
-        containerRef.current.style.filter = 'none';
-      }
-      if (blurEl) {
-        blurEl.setAttribute('stdDeviation', '0,0');
-      }
-
-      animationRef.current = null;
-
-      if (targetDigitRef.current !== target) {
-        requestAnimationFrame(() => {
-          animateToDigit(targetDigitRef.current);
-        });
-      }
-    };
-
-    anim.oncancel = () => {
-      animationRef.current = null;
-    };
-  };
-
-  return (
-    <>
-      <svg style={{ position: 'absolute', width: 0, height: 0 }} aria-hidden="true">
-        <defs>
-          <filter id={filterId}>
-            <feGaussianBlur in="SourceGraphic" stdDeviation="0,0" />
-          </filter>
-        </defs>
-      </svg>
-
-      <div
-        ref={containerRef}
-        style={{
-          position: 'relative',
-          height: `${digitHeight}px`,
-          overflow: 'hidden',
-          width: '0.65em',
-          textAlign: 'center',
-          opacity: isEntering ? 0 : 1,
-        }}
-      >
-        <div
-          ref={columnRef}
-          style={{
-            position: 'absolute',
-            left: 0,
-            right: 0,
-            willChange: 'transform',
-          }}
-        >
-          {sequence.map((d, i) => (
-            <div
-              key={i}
-              style={{
-                height: `${digitHeight}px`,
-                display: 'flex',
-                alignItems: 'center',
-                justifyContent: 'center',
-              }}
-            >
-              {d}
-            </div>
-          ))}
-        </div>
-      </div>
-    </>
-  );
-}
-
-export type { ISlidingNumberProps, IFormatOptions };

package/src/react-ui/primitives/waapi/SlidingText/SlidingText.styles.ts

@@ -1,32 +0,0 @@
-import type { StyleSlots } from '@/core/types';
-
-/**
- * Style slots for SlidingText component
- */
-export type SlidingTextSlot = 'root' | 'content' | 'token';
-
-/**
- * Base styles for SlidingText component
- */
-export const slidingTextBaseStyles: StyleSlots<SlidingTextSlot> = {
-  root: 'waapi-sliding-text-container',
-  content: 'waapi-sliding-text-content',
-  token: 'waapi-sliding-text-token',
-};
-
-/**
- * CSS classes for animation states
- */
-export const slidingTextAnimationClasses = {
-  enterFrom: 'enter-from',
-  enterTo: 'enter-to',
-  exitActive: 'exit-active',
-} as const;
-
-/**
- * CSS classes for direction variants
- */
-export const slidingTextDirectionClasses = {
-  vertical: 'waapi-direction-vertical',
-  horizontal: 'waapi-direction-horizontal',
-} as const;