{"version":3,"file":"constraint-solver.mjs","sources":["../../../../src/lib/layouts/adaptive/constraint-solver.ts"],"sourcesContent":["/**\n * @fileoverview Layout Constraint Solver\n *\n * Implements a sophisticated constraint-based layout solver that handles\n * complex layout requirements including min/max dimensions, aspect ratios,\n * spacing, ordering, and visibility constraints. Uses a priority-based\n * resolution system to handle conflicting constraints gracefully.\n *\n * The solver employs a relaxation algorithm that iteratively refines\n * positions and sizes until all required constraints are satisfied or\n * a stable state is reached.\n *\n * @module layouts/adaptive/constraint-solver\n * @version 1.0.0\n */\n\nimport type {\n  AlignmentConstraintParams,\n  AspectRatioConstraintParams,\n  ConstraintPriority,\n  ConstraintSolution,\n  ConstraintSolverInterface,\n  ConstraintViolation,\n  ContainmentConstraintParams,\n  Dimensions,\n  LayoutConstraint,\n  MinMaxConstraintParams,\n  OrderConstraintParams,\n  Point2D,\n  SpacingConstraintParams,\n  VisibilityConstraintParams,\n} from './types';\n\n// =============================================================================\n// CONSTANTS\n// =============================================================================\n\n/**\n * Maximum iterations for the relaxation algorithm.\n */\nconst MAX_ITERATIONS = 100;\n\n/**\n * Convergence threshold for position/size changes.\n */\nconst CONVERGENCE_THRESHOLD = 0.01;\n\n/**\n * Priority weights for constraint resolution.\n */\nconst PRIORITY_WEIGHTS: Record<ConstraintPriority, number> = {\n  required: 1000,\n  strong: 100,\n  medium: 10,\n  weak: 1,\n} as const;\n\n// =============================================================================\n// HELPER TYPES\n// =============================================================================\n\n/**\n * Internal representation of an item being solved.\n */\ninterface SolverItem {\n  id: string;\n  position: Point2D;\n  size: Dimensions;\n  constraints: LayoutConstraint[];\n  locked: boolean;\n}\n\n/**\n * Solution state during iteration.\n */\ninterface SolverState {\n  items: Map<string, SolverItem>;\n  containerDimensions: Dimensions;\n  iteration: number;\n  totalError: number;\n  converged: boolean;\n}\n\n// =============================================================================\n// CONSTRAINT SOLVER IMPLEMENTATION\n// =============================================================================\n\n/**\n * Layout constraint solver that handles complex layout requirements\n * using a priority-based relaxation algorithm.\n *\n * @example\n * ```typescript\n * const solver = new ConstraintSolver();\n * solver.addConstraint({\n *   id: 'min-width-card',\n *   type: 'min-width',\n *   priority: 'strong',\n *   params: { type: 'dimension', value: 200, unit: 'px' },\n *   active: true\n * });\n *\n * const solution = solver.solve(\n *   new Map([['card-1', { width: 150, height: 100 }]]),\n *   { width: 800, height: 600 }\n * );\n * ```\n */\nexport class ConstraintSolver implements ConstraintSolverInterface {\n  private readonly _constraints: Map<string, LayoutConstraint>;\n  private readonly _itemConstraints: Map<string, Set<string>>;\n\n  constructor() {\n    this._constraints = new Map();\n    this._itemConstraints = new Map();\n  }\n\n  /**\n   * Adds a new constraint to the solver.\n   *\n   * @param constraint - The constraint to add\n   */\n  addConstraint(constraint: LayoutConstraint): void {\n    this._constraints.set(constraint.id, constraint);\n  }\n\n  /**\n   * Removes a constraint from the solver.\n   *\n   * @param id - The constraint ID to remove\n   */\n  removeConstraint(id: string): void {\n    this._constraints.delete(id);\n\n    // Clean up item associations\n    for (const itemConstraints of this._itemConstraints.values()) {\n      itemConstraints.delete(id);\n    }\n  }\n\n  /**\n   * Updates an existing constraint.\n   *\n   * @param id - The constraint ID to update\n   * @param updates - Partial constraint updates\n   */\n  updateConstraint(id: string, updates: Partial<LayoutConstraint>): void {\n    const existing = this._constraints.get(id);\n    if (existing) {\n      this._constraints.set(id, { ...existing, ...updates } as LayoutConstraint);\n    }\n  }\n\n  /**\n   * Solves the constraint system for the given items and container.\n   *\n   * @param items - Map of item IDs to their current dimensions\n   * @param containerDimensions - Container dimensions\n   * @returns The constraint solution\n   */\n  solve(\n    items: ReadonlyMap<string, Dimensions>,\n    containerDimensions: Dimensions\n  ): ConstraintSolution {\n    const startTime = performance.now();\n\n    // Initialize solver state\n    const state = this._initializeState(items, containerDimensions);\n\n    // Run relaxation algorithm\n    while (!state.converged && state.iteration < MAX_ITERATIONS) {\n      this._iterate(state);\n      state.iteration++;\n    }\n\n    // Extract solution\n    const positions = new Map<string, Point2D>();\n    const sizes = new Map<string, Dimensions>();\n\n    for (const [id, item] of state.items) {\n      positions.set(id, { ...item.position });\n      sizes.set(id, { ...item.size });\n    }\n\n    // Validate and collect violations\n    const violations = this.validate({\n      feasible: true,\n      positions,\n      sizes,\n      violations: [],\n      solveTimeMs: 0,\n    });\n\n    const feasible = violations.every((v) => v.severity !== 'error');\n\n    return {\n      feasible,\n      positions,\n      sizes,\n      violations,\n      solveTimeMs: performance.now() - startTime,\n    };\n  }\n\n  /**\n   * Validates a solution against all active constraints.\n   *\n   * @param solution - The solution to validate\n   * @returns Array of constraint violations\n   */\n  validate(solution: ConstraintSolution): readonly ConstraintViolation[] {\n    const violations: ConstraintViolation[] = [];\n\n    for (const [_id, constraint] of this._constraints) {\n      if (!constraint.active) continue;\n\n      const violation = this._checkConstraint(constraint, solution);\n      if (violation) {\n        violations.push(violation);\n      }\n    }\n\n    return violations;\n  }\n\n  /**\n   * Clears all constraints from the solver.\n   */\n  clear(): void {\n    this._constraints.clear();\n    this._itemConstraints.clear();\n  }\n\n  // ===========================================================================\n  // PRIVATE METHODS\n  // ===========================================================================\n\n  /**\n   * Initializes the solver state from input items.\n   */\n  private _initializeState(\n    items: ReadonlyMap<string, Dimensions>,\n    containerDimensions: Dimensions\n  ): SolverState {\n    const solverItems = new Map<string, SolverItem>();\n    let currentX = 0;\n    let currentY = 0;\n\n    // Initialize items with default positions\n    for (const [id, dimensions] of items) {\n      const itemConstraints = Array.from(this._constraints.values()).filter(\n        (c) => c.active && this._constraintAppliesToItem(c, id)\n      );\n\n      solverItems.set(id, {\n        id,\n        position: { x: currentX, y: currentY },\n        size: { ...dimensions },\n        constraints: itemConstraints,\n        locked: false,\n      });\n\n      // Simple row layout for initial positions\n      currentX += dimensions.width + 16;\n      if (currentX + dimensions.width > containerDimensions.width) {\n        currentX = 0;\n        currentY += dimensions.height + 16;\n      }\n    }\n\n    return {\n      items: solverItems,\n      containerDimensions,\n      iteration: 0,\n      totalError: Infinity,\n      converged: false,\n    };\n  }\n\n  /**\n   * Performs one iteration of the relaxation algorithm.\n   */\n  private _iterate(state: SolverState): void {\n    let totalError = 0;\n    let maxDelta = 0;\n\n    for (const [_id, item] of state.items) {\n      if (item.locked) continue;\n\n      for (const constraint of item.constraints) {\n        const delta = this._applyConstraint(item, constraint, state);\n        maxDelta = Math.max(maxDelta, delta);\n        totalError += delta * PRIORITY_WEIGHTS[constraint.priority];\n      }\n    }\n\n    // Apply containment constraints\n    for (const [_id2, item] of state.items) {\n      const delta = this._applyContainment(item, state.containerDimensions);\n      maxDelta = Math.max(maxDelta, delta);\n    }\n\n    state.totalError = totalError;\n    state.converged = maxDelta < CONVERGENCE_THRESHOLD;\n  }\n\n  /**\n   * Applies a single constraint to an item.\n   */\n  private _applyConstraint(\n    item: SolverItem,\n    constraint: LayoutConstraint,\n    state: SolverState\n  ): number {\n    // const _weight = PRIORITY_WEIGHTS[constraint.priority];\n    const { params } = constraint;\n\n    switch (constraint.type) {\n      case 'min-width':\n        return this._applyMinWidth(item, params as MinMaxConstraintParams, state);\n      case 'max-width':\n        return this._applyMaxWidth(item, params as MinMaxConstraintParams, state);\n      case 'min-height':\n        return this._applyMinHeight(item, params as MinMaxConstraintParams, state);\n      case 'max-height':\n        return this._applyMaxHeight(item, params as MinMaxConstraintParams, state);\n      case 'aspect-ratio':\n        return this._applyAspectRatio(item, params as AspectRatioConstraintParams);\n      case 'alignment':\n        return this._applyAlignment(item, params as AlignmentConstraintParams, state);\n      case 'spacing':\n        return this._applySpacing(item, params as SpacingConstraintParams, state);\n      case 'order':\n        return this._applyOrder(item, params as OrderConstraintParams, state);\n      case 'visibility':\n        return this._applyVisibility(item, params as VisibilityConstraintParams, state);\n      case 'containment':\n        return this._applyContainmentConstraint(item, params as ContainmentConstraintParams, state);\n      default:\n        return 0;\n    }\n  }\n\n  /**\n   * Applies minimum width constraint.\n   */\n  private _applyMinWidth(\n    item: SolverItem,\n    params: MinMaxConstraintParams,\n    state: SolverState\n  ): number {\n    const minWidth = this._resolveValue(params.value, params.unit, state.containerDimensions.width);\n    if (item.size.width < minWidth) {\n      const delta = minWidth - item.size.width;\n      item.size = { ...item.size, width: minWidth };\n      return delta;\n    }\n    return 0;\n  }\n\n  /**\n   * Applies maximum width constraint.\n   */\n  private _applyMaxWidth(\n    item: SolverItem,\n    params: MinMaxConstraintParams,\n    state: SolverState\n  ): number {\n    const maxWidth = this._resolveValue(params.value, params.unit, state.containerDimensions.width);\n    if (item.size.width > maxWidth) {\n      const delta = item.size.width - maxWidth;\n      item.size = { ...item.size, width: maxWidth };\n      return delta;\n    }\n    return 0;\n  }\n\n  /**\n   * Applies minimum height constraint.\n   */\n  private _applyMinHeight(\n    item: SolverItem,\n    params: MinMaxConstraintParams,\n    state: SolverState\n  ): number {\n    const minHeight = this._resolveValue(\n      params.value,\n      params.unit,\n      state.containerDimensions.height\n    );\n    if (item.size.height < minHeight) {\n      const delta = minHeight - item.size.height;\n      item.size = { ...item.size, height: minHeight };\n      return delta;\n    }\n    return 0;\n  }\n\n  /**\n   * Applies maximum height constraint.\n   */\n  private _applyMaxHeight(\n    item: SolverItem,\n    params: MinMaxConstraintParams,\n    state: SolverState\n  ): number {\n    const maxHeight = this._resolveValue(\n      params.value,\n      params.unit,\n      state.containerDimensions.height\n    );\n    if (item.size.height > maxHeight) {\n      const delta = item.size.height - maxHeight;\n      item.size = { ...item.size, height: maxHeight };\n      return delta;\n    }\n    return 0;\n  }\n\n  /**\n   * Applies aspect ratio constraint.\n   */\n  private _applyAspectRatio(item: SolverItem, params: AspectRatioConstraintParams): number {\n    const currentRatio = item.size.width / item.size.height;\n    const diff = Math.abs(currentRatio - params.ratio);\n\n    if (diff > params.tolerance) {\n      // Adjust height to match desired ratio while preserving width\n      const newHeight = item.size.width / params.ratio;\n      const delta = Math.abs(newHeight - item.size.height);\n      item.size = { ...item.size, height: newHeight };\n      return delta;\n    }\n    return 0;\n  }\n\n  /**\n   * Applies alignment constraint.\n   */\n  private _applyAlignment(\n    item: SolverItem,\n    params: AlignmentConstraintParams,\n    state: SolverState\n  ): number {\n    let deltaX = 0;\n    let deltaY = 0;\n\n    // Horizontal alignment\n    switch (params.horizontal) {\n      case 'center': {\n        const centerX = (state.containerDimensions.width - item.size.width) / 2;\n        deltaX = Math.abs(centerX - item.position.x);\n        item.position = { ...item.position, x: centerX };\n        break;\n      }\n      case 'end': {\n        const endX = state.containerDimensions.width - item.size.width;\n        deltaX = Math.abs(endX - item.position.x);\n        item.position = { ...item.position, x: endX };\n        break;\n      }\n      case 'start':\n        deltaX = Math.abs(item.position.x);\n        item.position = { ...item.position, x: 0 };\n        break;\n      case 'stretch':\n        deltaX = Math.abs(state.containerDimensions.width - item.size.width);\n        item.size = { ...item.size, width: state.containerDimensions.width };\n        item.position = { ...item.position, x: 0 };\n        break;\n    }\n\n    // Vertical alignment\n    switch (params.vertical) {\n      case 'center': {\n        const centerY = (state.containerDimensions.height - item.size.height) / 2;\n        deltaY = Math.abs(centerY - item.position.y);\n        item.position = { ...item.position, y: centerY };\n        break;\n      }\n      case 'end': {\n        const endY = state.containerDimensions.height - item.size.height;\n        deltaY = Math.abs(endY - item.position.y);\n        item.position = { ...item.position, y: endY };\n        break;\n      }\n      case 'start':\n        deltaY = Math.abs(item.position.y);\n        item.position = { ...item.position, y: 0 };\n        break;\n      case 'stretch':\n        deltaY = Math.abs(state.containerDimensions.height - item.size.height);\n        item.size = { ...item.size, height: state.containerDimensions.height };\n        item.position = { ...item.position, y: 0 };\n        break;\n    }\n\n    return deltaX + deltaY;\n  }\n\n  /**\n   * Applies spacing constraint between items.\n   */\n  private _applySpacing(\n    item: SolverItem,\n    params: SpacingConstraintParams,\n    state: SolverState\n  ): number {\n    let totalDelta = 0;\n\n    // Find nearest neighbors and adjust spacing\n    for (const [otherId, other] of state.items) {\n      if (otherId === item.id) continue;\n\n      const dx = other.position.x - (item.position.x + item.size.width);\n      const dy = other.position.y - (item.position.y + item.size.height);\n\n      // Check horizontal spacing\n      if (Math.abs(dy) < item.size.height) {\n        if (dx > 0 && dx < params.min) {\n          const adjustment = (params.min - dx) / 2;\n          item.position = { ...item.position, x: item.position.x - adjustment };\n          other.position = { ...other.position, x: other.position.x + adjustment };\n          totalDelta += adjustment * 2;\n        } else if (dx > params.max) {\n          const adjustment = (dx - params.max) / 2;\n          item.position = { ...item.position, x: item.position.x + adjustment };\n          other.position = { ...other.position, x: other.position.x - adjustment };\n          totalDelta += adjustment * 2;\n        }\n      }\n\n      // Check vertical spacing\n      if (Math.abs(dx) < item.size.width) {\n        if (dy > 0 && dy < params.min) {\n          const adjustment = (params.min - dy) / 2;\n          item.position = { ...item.position, y: item.position.y - adjustment };\n          other.position = { ...other.position, y: other.position.y + adjustment };\n          totalDelta += adjustment * 2;\n        } else if (dy > params.max) {\n          const adjustment = (dy - params.max) / 2;\n          item.position = { ...item.position, y: item.position.y + adjustment };\n          other.position = { ...other.position, y: other.position.y - adjustment };\n          totalDelta += adjustment * 2;\n        }\n      }\n    }\n\n    return totalDelta;\n  }\n\n  /**\n   * Applies ordering constraint.\n   */\n  private _applyOrder(item: SolverItem, params: OrderConstraintParams, state: SolverState): number {\n    let totalDelta = 0;\n\n    // Ensure item comes before specified items\n    if (params.before) {\n      for (const beforeId of params.before) {\n        const beforeItem = state.items.get(beforeId);\n        if (beforeItem && item.position.y >= beforeItem.position.y) {\n          const delta = item.position.y - beforeItem.position.y + item.size.height + 16;\n          beforeItem.position = { ...beforeItem.position, y: beforeItem.position.y + delta };\n          totalDelta += delta;\n        }\n      }\n    }\n\n    // Ensure item comes after specified items\n    if (params.after) {\n      for (const afterId of params.after) {\n        const afterItem = state.items.get(afterId);\n        if (afterItem && item.position.y <= afterItem.position.y + afterItem.size.height) {\n          const delta = afterItem.position.y + afterItem.size.height + 16 - item.position.y;\n          item.position = { ...item.position, y: item.position.y + delta };\n          totalDelta += delta;\n        }\n      }\n    }\n\n    return totalDelta;\n  }\n\n  /**\n   * Applies visibility constraint.\n   */\n  private _applyVisibility(\n    item: SolverItem,\n    params: VisibilityConstraintParams,\n    state: SolverState\n  ): number {\n    // For viewport visibility, ensure item is within container bounds\n    if (params.condition === 'viewport' || params.condition === 'container') {\n      return this._applyContainment(item, state.containerDimensions);\n    }\n    return 0;\n  }\n\n  /**\n   * Applies containment constraint.\n   */\n  private _applyContainmentConstraint(\n    item: SolverItem,\n    params: ContainmentConstraintParams,\n    state: SolverState\n  ): number {\n    if (!params.contain) return 0;\n    return this._applyContainment(item, state.containerDimensions);\n  }\n\n  /**\n   * Ensures item stays within container bounds.\n   */\n  private _applyContainment(item: SolverItem, containerDimensions: Dimensions): number {\n    let delta = 0;\n\n    // Left edge\n    if (item.position.x < 0) {\n      delta += Math.abs(item.position.x);\n      item.position = { ...item.position, x: 0 };\n    }\n\n    // Top edge\n    if (item.position.y < 0) {\n      delta += Math.abs(item.position.y);\n      item.position = { ...item.position, y: 0 };\n    }\n\n    // Right edge\n    const rightOverflow = item.position.x + item.size.width - containerDimensions.width;\n    if (rightOverflow > 0) {\n      delta += rightOverflow;\n      item.position = { ...item.position, x: containerDimensions.width - item.size.width };\n    }\n\n    // Bottom edge (only if container has fixed height)\n    if (containerDimensions.height > 0) {\n      const bottomOverflow = item.position.y + item.size.height - containerDimensions.height;\n      if (bottomOverflow > 0) {\n        delta += bottomOverflow;\n        // For bottom overflow, we might need to reduce size or scroll\n        // For now, just adjust position\n        item.position = {\n          ...item.position,\n          y: Math.max(0, containerDimensions.height - item.size.height),\n        };\n      }\n    }\n\n    return delta;\n  }\n\n  /**\n   * Resolves a value with unit to pixels.\n   */\n  private _resolveValue(value: number, unit: string, reference: number): number {\n    switch (unit) {\n      case '%':\n        return (value / 100) * reference;\n      case 'vw':\n        return (value / 100) * (typeof window !== 'undefined' ? window.innerWidth : reference);\n      case 'vh':\n        return (value / 100) * (typeof window !== 'undefined' ? window.innerHeight : reference);\n      case 'px':\n      default:\n        return value;\n    }\n  }\n\n  /**\n   * Checks if a constraint applies to a specific item.\n   */\n  private _constraintAppliesToItem(_constraint: LayoutConstraint, _itemId: string): boolean {\n    // For simplicity, all constraints apply to all items\n    // In a more sophisticated system, constraints would specify target items\n    return true;\n  }\n\n  /**\n   * Checks a single constraint and returns a violation if violated.\n   */\n  private _checkConstraint(\n    constraint: LayoutConstraint,\n    solution: ConstraintSolution\n  ): ConstraintViolation | null {\n    const affectedItems: string[] = [];\n    let violated = false;\n    let message = '';\n\n    for (const [id, size] of solution.sizes) {\n      const { params } = constraint;\n\n      switch (constraint.type) {\n        case 'min-width':\n          if (params.type === 'dimension' && size.width < params.value) {\n            violated = true;\n            affectedItems.push(id);\n            message = `Width ${size.width}px is less than minimum ${params.value}${params.unit}`;\n          }\n          break;\n        case 'max-width':\n          if (params.type === 'dimension' && size.width > params.value) {\n            violated = true;\n            affectedItems.push(id);\n            message = `Width ${size.width}px exceeds maximum ${params.value}${params.unit}`;\n          }\n          break;\n        case 'min-height':\n          if (params.type === 'dimension' && size.height < params.value) {\n            violated = true;\n            affectedItems.push(id);\n            message = `Height ${size.height}px is less than minimum ${params.value}${params.unit}`;\n          }\n          break;\n        case 'max-height':\n          if (params.type === 'dimension' && size.height > params.value) {\n            violated = true;\n            affectedItems.push(id);\n            message = `Height ${size.height}px exceeds maximum ${params.value}${params.unit}`;\n          }\n          break;\n        case 'aspect-ratio':\n          if (params.type === 'aspect-ratio') {\n            const ratio = size.width / size.height;\n            if (Math.abs(ratio - params.ratio) > params.tolerance) {\n              violated = true;\n              affectedItems.push(id);\n              message = `Aspect ratio ${ratio.toFixed(2)} differs from required ${params.ratio} by more than tolerance ${params.tolerance}`;\n            }\n          }\n          break;\n      }\n    }\n\n    if (violated) {\n      return {\n        constraintId: constraint.id,\n        severity: constraint.priority === 'required' ? 'error' : 'warning',\n        message,\n        affectedItems,\n      };\n    }\n\n    return null;\n  }\n}\n\n// =============================================================================\n// FACTORY FUNCTION\n// =============================================================================\n\n/**\n * Creates a new ConstraintSolver instance.\n *\n * @returns A new ConstraintSolver instance\n */\nexport function createConstraintSolver(): ConstraintSolverInterface {\n  return new ConstraintSolver();\n}\n"],"names":["PRIORITY_WEIGHTS","ConstraintSolver","constraint","id","itemConstraints","updates","existing","items","containerDimensions","startTime","state","positions","sizes","item","violations","v","solution","_id","violation","solverItems","currentX","currentY","dimensions","c","totalError","maxDelta","delta","_id2","params","minWidth","maxWidth","minHeight","maxHeight","currentRatio","newHeight","deltaX","deltaY","centerX","endX","centerY","endY","totalDelta","otherId","other","dx","dy","adjustment","beforeId","beforeItem","afterId","afterItem","rightOverflow","bottomOverflow","value","unit","reference","_constraint","_itemId","affectedItems","violated","message","size","ratio","createConstraintSolver"],"mappings":"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"}