@agent-native/core 0.131.4 → 0.131.6

package/corpus/templates/design/app/components/design/inspector/scrub-input-utils.ts

@@ -1,311 +1,15 @@
-export interface ScrubExpressionOptions {
-  unit?: string;
-  min?: number;
-  max?: number;
-  precision?: number;
-}
-
-// ─── Scrub-drag gesture-lifecycle state machine ───────────────────────────────
-//
-// Pure mirror of the pointerdown/pointermove/pointerup bookkeeping in
-// ScrubInput's dragRef, extracted so the "exactly one commit-phase emission
-// per gesture" contract can be unit tested without simulating real DOM
-// pointer events (this template has no jsdom/testing-library dependency).
-
-/** Cumulative pointer movement (px) required before a drag start is treated
- * as a real scrub rather than jitter during a plain click. Mirrors
- * ScrubInput's DRAG_THRESHOLD_PX. */
-export const SCRUB_DRAG_THRESHOLD_PX = 3;
-
-export interface ScrubDragState {
-  startX: number;
-  prevX: number;
-  hasDragged: boolean;
-}
-
-/** Begins tracking a new scrub gesture at the given starting pointer X. */
-export function startScrubDrag(startX: number): ScrubDragState {
-  return { startX, prevX: startX, hasDragged: false };
-}
-
-export interface ScrubDragTick {
-  /** The updated drag state after this pointermove sample. */
-  state: ScrubDragState;
-  /** The incremental delta (px) to apply this tick, or null when the move
-   * should be ignored (no movement, or still under the jitter threshold). */
-  deltaX: number | null;
-}
-
-/**
- * Processes one pointermove sample against the in-progress drag state.
- * Mirrors ScrubInput's handlePointerMove threshold/hasDragged logic exactly:
- * a move is ignored until cumulative movement clears SCRUB_DRAG_THRESHOLD_PX,
- * after which every subsequent move (including this one) yields an
- * incremental delta and marks the gesture as a real drag.
- */
-export function updateScrubDrag(
-  state: ScrubDragState,
-  clientX: number,
-): ScrubDragTick {
-  const incr = clientX - state.prevX;
-  if (incr === 0) {
-    return { state, deltaX: null };
-  }
-  const cumulativeDelta = Math.abs(clientX - state.startX);
-  if (!state.hasDragged && cumulativeDelta < SCRUB_DRAG_THRESHOLD_PX) {
-    return { state: { ...state, prevX: clientX }, deltaX: null };
-  }
-  return {
-    state: { ...state, prevX: clientX, hasDragged: true },
-    deltaX: incr,
-  };
-}
-
-export interface ParsedScrubExpression {
-  value: number;
-  normalized: string;
-}
-
-type MathOperator = "+" | "-" | "*" | "/";
-
-type Token =
-  | { type: "number"; value: number }
-  | { type: "operator"; value: MathOperator };
-
-const NUMBER_CHAR_PATTERN = /[0-9.]/;
-// Comma is only treated as a digit character while scanning a number token
-// (see tokenizeExpression) so a locale-style decimal comma ("12,5") parses as
-// 12.5, without swallowing the "," that a caller might use to separate
-// distinct expressions elsewhere.
-const NUMBER_OR_COMMA_CHAR_PATTERN = /[0-9.,]/;
-
-export function parseScrubExpression(
-  input: string,
-  currentValue: number,
-  options: ScrubExpressionOptions = {},
-): ParsedScrubExpression | null {
-  const raw = input.trim();
-  if (!raw) return null;
-
-  const expression = toNumericExpression(raw, currentValue, options.unit);
-  const value = evaluateNumericExpression(expression);
-  if (value === null) return null;
-
-  const normalizedValue = normalizeScrubNumber(value, options);
-  return {
-    value: normalizedValue,
-    normalized: formatScrubValue(normalizedValue, options),
-  };
-}
-
-export function normalizeScrubNumber(
-  value: number,
-  options: ScrubExpressionOptions = {},
-): number {
-  if (!Number.isFinite(value)) return 0;
-
-  let next = value;
-  if (Number.isFinite(options.min)) next = Math.max(options.min!, next);
-  if (Number.isFinite(options.max)) next = Math.min(options.max!, next);
-  if (Number.isFinite(options.precision)) {
-    const scale = 10 ** Math.max(0, options.precision!);
-    next = Math.round(next * scale) / scale;
-  }
-  return Object.is(next, -0) ? 0 : next;
-}
-
-/**
- * Whether a field's unit should snap to whole numbers while the user is
- * actively pointer-dragging (scrubbing) it. Px-type fields (padding, gap,
- * position, size, radius, etc.) read as integers in Figma-style editors even
- * though the underlying `precision` option (which also governs *typed* input
- * and keyboard nudges) allows one decimal place so a typed "12.5" still
- * commits legally. Scoped to "px" specifically — unitless fields like
- * line-height (precision-based, fractional by design) and other units (deg,
- * %) are untouched.
- */
-export function scrubSnapsToInteger(unit: string | undefined): boolean {
-  return unit === "px";
-}
-
-/**
- * Rounds a live scrub-drag value to a whole number when the field's unit
- * calls for integer-only scrubbing (see `scrubSnapsToInteger`), applied
- * *before* `normalizeScrubNumber`'s own min/max/precision clamp so a
- * following precision clamp (if any) can't reintroduce a fraction. Only the
- * pointer-drag scrub gesture should call this — typed input and keyboard
- * nudges keep their existing `precision`-based rounding untouched.
- */
-export function roundScrubDragValue(
-  value: number,
-  unit: string | undefined,
-): number {
-  return scrubSnapsToInteger(unit) ? Math.round(value) : value;
-}
-
-export function formatScrubValue(
-  value: number,
-  options: Pick<ScrubExpressionOptions, "precision" | "unit"> = {},
-): string {
-  const normalized = normalizeScrubNumber(value, options);
-  let numeric: string;
-  if (Number.isFinite(options.precision) && options.precision! >= 0) {
-    const fixed = normalized.toFixed(options.precision!);
-    if (options.unit) {
-      // For fields with units (px, %, °, etc.) collapse all trailing zeros
-      // including the decimal point: "12.30px" → "12.3px", "10.00px" → "10px".
-      // Leave integer strings alone; otherwise precision 0 turns "100" into "1".
-      numeric = fixed.includes(".") ? fixed.replace(/\.?0+$/, "") : fixed;
-    } else {
-      // For unitless fields (e.g. line-height), preserve at least one decimal
-      // digit so values like "2.0" stay "2.0" rather than collapsing to "2".
-      // Only strip redundant trailing zeros beyond the first decimal digit.
-      numeric = fixed.includes(".") ? fixed.replace(/(?<=\.\d)0+$/, "") : fixed;
-    }
-  } else {
-    numeric = String(normalized);
-  }
-  return `${numeric}${options.unit ?? ""}`;
-}
-
-export function getScrubStepFromEvent(
-  event: Pick<KeyboardEvent | PointerEvent, "altKey" | "shiftKey">,
-  step: number,
-): number {
-  // Alt (fine-step) and Shift (coarse) are mutually exclusive — alt takes
-  // priority, matching Figma's modifier convention. Applying both independently
-  // would make Shift+Alt a no-op (×10 × 0.1 = ×1).
-  let multiplier = 1;
-  if (event.altKey) multiplier = 0.1;
-  else if (event.shiftKey) multiplier = 10;
-  return step * multiplier;
-}
-
-function toNumericExpression(
-  raw: string,
-  currentValue: number,
-  unit?: string,
-): string {
-  let expression = raw.trim();
-
-  if (unit) {
-    expression = expression.replace(new RegExp(escapeRegExp(unit), "gi"), "");
-  }
-
-  if (expression.startsWith("=")) return expression.slice(1).trim();
-  if (/^[+\-*/]/.test(expression)) return `${currentValue}${expression}`;
-  return expression;
-}
-
-function evaluateNumericExpression(expression: string): number | null {
-  const tokens = tokenizeExpression(expression);
-  if (!tokens.length) return null;
-
-  const values: number[] = [];
-  const operators: MathOperator[] = [];
-
-  for (const token of tokens) {
-    if (token.type === "number") {
-      values.push(token.value);
-      continue;
-    }
-
-    while (
-      operators.length &&
-      precedence(operators[operators.length - 1]) >= precedence(token.value)
-    ) {
-      if (!applyTopOperator(values, operators)) return null;
-    }
-    operators.push(token.value);
-  }
-
-  while (operators.length) {
-    if (!applyTopOperator(values, operators)) return null;
-  }
-
-  if (values.length !== 1 || !Number.isFinite(values[0])) return null;
-  return values[0];
-}
-
-function tokenizeExpression(expression: string): Token[] {
-  const tokens: Token[] = [];
-  let index = 0;
-  let previousWasOperator = true;
-
-  while (index < expression.length) {
-    const char = expression[index];
-    if (/\s/.test(char)) {
-      index += 1;
-      continue;
-    }
-
-    const signedNumber =
-      (char === "+" || char === "-") &&
-      previousWasOperator &&
-      NUMBER_CHAR_PATTERN.test(expression[index + 1] ?? "");
-
-    if (NUMBER_CHAR_PATTERN.test(char) || signedNumber) {
-      const start = index;
-      index += 1;
-      // Allow a single comma decimal separator within this number token
-      // ("12,5" → 12.5), matching common European locale input. A second
-      // comma/period is left for the caller's Number() parse to reject.
-      while (NUMBER_OR_COMMA_CHAR_PATTERN.test(expression[index] ?? ""))
-        index += 1;
-      const value = Number(expression.slice(start, index).replace(",", "."));
-      if (!Number.isFinite(value)) return [];
-      tokens.push({ type: "number", value });
-      previousWasOperator = false;
-      continue;
-    }
-
-    if (isOperator(char)) {
-      tokens.push({ type: "operator", value: char });
-      previousWasOperator = true;
-      index += 1;
-      continue;
-    }
-
-    return [];
-  }
-
-  return tokens;
-}
-
-function applyTopOperator(
-  values: number[],
-  operators: MathOperator[],
-): boolean {
-  const operator = operators.pop();
-  const right = values.pop();
-  const left = values.pop();
-  if (!operator || right === undefined || left === undefined) return false;
-
-  switch (operator) {
-    case "+":
-      values.push(left + right);
-      return true;
-    case "-":
-      values.push(left - right);
-      return true;
-    case "*":
-      values.push(left * right);
-      return true;
-    case "/":
-      if (right === 0) return false;
-      values.push(left / right);
-      return true;
-  }
-}
-
-function precedence(operator: MathOperator): number {
-  return operator === "*" || operator === "/" ? 2 : 1;
-}
-
-function isOperator(char: string): char is MathOperator {
-  return char === "+" || char === "-" || char === "*" || char === "/";
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+export {
+  formatScrubValue,
+  getScrubStepFromEvent,
+  normalizeScrubNumber,
+  parseScrubExpression,
+  roundScrubDragValue,
+  scrubSnapsToInteger,
+  SCRUB_DRAG_THRESHOLD_PX,
+  startScrubDrag,
+  updateScrubDrag,
+  type ParsedScrubExpression,
+  type ScrubDragState,
+  type ScrubDragTick,
+  type ScrubExpressionOptions,
+} from "@agent-native/toolkit/design-tweaks";