{"version":3,"file":"optional-segments.mjs","sources":["../../../../src/lib/routing/advanced/optional-segments.ts"],"sourcesContent":["/**\n * @file Optional Route Segments Support\n * @description Implements optional route segment patterns for flexible URL matching.\n * Enables routes that can match with or without certain path segments.\n *\n * @module @/lib/routing/advanced/optional-segments\n *\n * This module provides:\n * - Optional segment definitions\n * - Default value handling\n * - Conditional segment rendering\n * - Type-safe optional params\n * - Segment presence detection\n *\n * @example\n * ```typescript\n * import { OptionalSegment, createOptionalSegment } from '@/lib/routing/advanced/optional-segments';\n *\n * // Route: /products/[[category]]/[[page]]\n * const segment = createOptionalSegment({\n *   name: 'category',\n *   defaultValue: 'all',\n *   validate: (v) => ['all', 'electronics', 'clothing'].includes(v),\n * });\n *\n * const value = segment.resolve('/products'); // 'all'\n * const value2 = segment.resolve('/products/electronics'); // 'electronics'\n * ```\n */\n\n// =============================================================================\n// Types\n// =============================================================================\n\n/**\n * Optional segment configuration\n */\nexport interface OptionalSegmentConfig<T = string> {\n  /** Segment parameter name */\n  readonly name: string;\n  /** Default value when segment is not present */\n  readonly defaultValue: T;\n  /** Validate segment value */\n  readonly validate?: (value: string) => boolean;\n  /** Transform segment value */\n  readonly transform?: (value: string) => T;\n  /** Allowed values (enum-style) */\n  readonly allowedValues?: readonly T[];\n  /** Position in the path (0-indexed from optional segments) */\n  readonly position?: number;\n  /** Description for documentation */\n  readonly description?: string;\n  /** Feature flag for this segment */\n  readonly featureFlag?: string;\n}\n\n/**\n * Optional segment resolution result\n */\nexport interface OptionalSegmentResolution<T = string> {\n  /** Whether segment was present in path */\n  readonly present: boolean;\n  /** Resolved value (actual or default) */\n  readonly value: T;\n  /** Raw string value (before transformation) */\n  readonly rawValue: string | null;\n  /** Validation result */\n  readonly valid: boolean;\n  /** Validation error (if any) */\n  readonly error: string | null;\n}\n\n/**\n * Route with optional segments\n */\nexport interface OptionalSegmentRoute {\n  /** Base path (static portion) */\n  readonly basePath: string;\n  /** Optional segments in order */\n  readonly segments: readonly OptionalSegmentConfig[];\n  /** Full pattern string */\n  readonly pattern: string;\n  /** Minimum path length (static + required) */\n  readonly minLength: number;\n  /** Maximum path length (static + all optional) */\n  readonly maxLength: number;\n}\n\n/**\n * Match result for optional segment route\n */\nexport interface OptionalRouteMatch {\n  /** Whether path matches the route */\n  readonly matches: boolean;\n  /** Resolved segment values */\n  readonly values: Record<string, unknown>;\n  /** Which segments were present */\n  readonly presentSegments: readonly string[];\n  /** Which segments used defaults */\n  readonly defaultedSegments: readonly string[];\n  /** Validation errors by segment */\n  readonly errors: Record<string, string>;\n  /** Match score for priority sorting */\n  readonly score: number;\n}\n\n/**\n * Optional segment builder configuration\n */\nexport interface OptionalRouteBuilderConfig {\n  /** Base path */\n  readonly basePath: string;\n  /** Segments to add */\n  readonly segments: readonly OptionalSegmentConfig[];\n  /** Strict mode (reject unknown segments) */\n  readonly strict?: boolean;\n}\n\n// =============================================================================\n// OptionalSegment Class\n// =============================================================================\n\n/**\n * Manages a single optional segment\n *\n * @example\n * ```typescript\n * const segment = new OptionalSegment({\n *   name: 'page',\n *   defaultValue: '1',\n *   transform: (v) => parseInt(v, 10),\n *   validate: (v) => /^\\d+$/.test(v),\n * });\n *\n * const result = segment.resolve('5');\n * // { present: true, value: 5, rawValue: '5', valid: true, error: null }\n * ```\n */\nexport class OptionalSegment<T = string> {\n  private readonly config: OptionalSegmentConfig<T>;\n\n  constructor(config: OptionalSegmentConfig<T>) {\n    this.config = config;\n  }\n\n  /**\n   * Get segment name\n   */\n  getName(): string {\n    return this.config.name;\n  }\n\n  /**\n   * Get default value\n   */\n  getDefault(): T {\n    return this.config.defaultValue;\n  }\n\n  /**\n   * Resolve a segment value\n   *\n   * @param value - Raw segment value or undefined\n   * @returns Resolution result\n   */\n  resolve(value: string | undefined | null): OptionalSegmentResolution<T> {\n    // Not present - use default\n    if (value === undefined || value === null || value === '') {\n      return {\n        present: false,\n        value: this.config.defaultValue,\n        rawValue: null,\n        valid: true,\n        error: null,\n      };\n    }\n\n    // Validate\n    if (this.config.validate && !this.config.validate(value)) {\n      return {\n        present: true,\n        value: this.config.defaultValue,\n        rawValue: value,\n        valid: false,\n        error: `Invalid value for segment \"${this.config.name}\": ${value}`,\n      };\n    }\n\n    // Check allowed values\n    if (this.config.allowedValues && this.config.allowedValues.length > 0) {\n      const transformed = this.config.transform ? this.config.transform(value) : (value as unknown as T);\n      if (!this.config.allowedValues.includes(transformed)) {\n        return {\n          present: true,\n          value: this.config.defaultValue,\n          rawValue: value,\n          valid: false,\n          error: `Value \"${value}\" not in allowed values for \"${this.config.name}\"`,\n        };\n      }\n    }\n\n    // Transform\n    const transformedValue = this.config.transform\n      ? this.config.transform(value)\n      : (value as unknown as T);\n\n    return {\n      present: true,\n      value: transformedValue,\n      rawValue: value,\n      valid: true,\n      error: null,\n    };\n  }\n\n  /**\n   * Get the pattern string for this segment\n   */\n  getPatternString(): string {\n    return `[[${this.config.name}]]`;\n  }\n\n  /**\n   * Get configuration\n   */\n  getConfig(): Readonly<OptionalSegmentConfig<T>> {\n    return this.config;\n  }\n}\n\n// =============================================================================\n// OptionalSegmentRoute Class\n// =============================================================================\n\n/**\n * Manages a route with optional segments\n *\n * @example\n * ```typescript\n * const route = new OptionalSegmentRouteBuilder({\n *   basePath: '/products',\n *   segments: [\n *     { name: 'category', defaultValue: 'all' },\n *     { name: 'page', defaultValue: '1', transform: (v) => parseInt(v, 10) },\n *   ],\n * });\n *\n * const match = route.match('/products/electronics/2');\n * // { matches: true, values: { category: 'electronics', page: 2 }, ... }\n * ```\n */\nexport class OptionalSegmentRouteBuilder {\n  private readonly config: OptionalRouteBuilderConfig;\n  private readonly segments: Map<string, OptionalSegment>;\n  private readonly orderedSegments: OptionalSegment[];\n  private readonly pattern: RegExp;\n\n  constructor(config: OptionalRouteBuilderConfig) {\n    this.config = {\n      ...config,\n      strict: config.strict ?? false,\n    };\n    this.segments = new Map();\n    this.orderedSegments = [];\n\n    // Initialize segments\n    for (const segConfig of config.segments) {\n      const segment = new OptionalSegment(segConfig);\n      this.segments.set(segConfig.name, segment);\n      this.orderedSegments.push(segment);\n    }\n\n    // Build pattern\n    this.pattern = this.buildPattern();\n  }\n\n  /**\n   * Match a path against this route\n   *\n   * @param path - URL path to match\n   * @returns Match result\n   */\n  match(path: string): OptionalRouteMatch {\n    const normalizedPath = path.replace(/\\/$/, '') || '/';\n    const match = normalizedPath.match(this.pattern);\n\n    if (!match) {\n      return {\n        matches: false,\n        values: {},\n        presentSegments: [],\n        defaultedSegments: [],\n        errors: {},\n        score: 0,\n      };\n    }\n\n    const values: Record<string, unknown> = {};\n    const presentSegments: string[] = [];\n    const defaultedSegments: string[] = [];\n    const errors: Record<string, string> = {};\n\n    // Resolve each segment\n    for (let i = 0; i < this.orderedSegments.length; i++) {\n      const segment = this.orderedSegments[i];\n      if (!segment) continue;\n      const rawValue = match[i + 1]; // +1 because match[0] is full match\n\n      const resolution = segment.resolve(rawValue);\n      values[segment.getName()] = resolution.value;\n\n      if (resolution.present) {\n        presentSegments.push(segment.getName());\n      } else {\n        defaultedSegments.push(segment.getName());\n      }\n\n      if (!resolution.valid && resolution.error != null && resolution.error !== '') {\n        errors[segment.getName()] = resolution.error;\n      }\n    }\n\n    // Calculate score (more present segments = higher score)\n    const score = presentSegments.length * 10 + this.config.basePath.split('/').length;\n\n    return {\n      matches: Object.keys(errors).length === 0,\n      values,\n      presentSegments,\n      defaultedSegments,\n      errors,\n      score,\n    };\n  }\n\n  /**\n   * Build a path from segment values\n   *\n   * @param values - Segment values\n   * @param options - Build options\n   * @returns Built path\n   */\n  buildPath(\n    values: Partial<Record<string, unknown>>,\n    options: { includeDefaults?: boolean } = {}\n  ): string {\n    const parts = [this.config.basePath.replace(/\\/$/, '')];\n\n    for (const segment of this.orderedSegments) {\n      const value = values[segment.getName()];\n      const defaultValue = segment.getDefault();\n\n      if (value !== undefined && value !== null) {\n        // Include non-default values\n        if (value !== defaultValue || options.includeDefaults === true) {\n          const stringValue = typeof value === 'object'\n            ? JSON.stringify(value)\n            : String(value as string | number | boolean);\n          parts.push(stringValue);\n        } else {\n          // Stop at first default (unless includeDefaults)\n          break;\n        }\n      } else {\n        // Stop at first missing value\n        break;\n      }\n    }\n\n    return parts.join('/') || '/';\n  }\n\n  /**\n   * Get pattern string for display\n   */\n  getPatternString(): string {\n    const basePath = this.config.basePath.replace(/\\/$/, '');\n    const segmentPatterns = this.orderedSegments\n      .map(s => s.getPatternString())\n      .join('/');\n\n    return `${basePath}/${segmentPatterns}`;\n  }\n\n  /**\n   * Get segment by name\n   *\n   * @param name - Segment name\n   */\n  getSegment(name: string): OptionalSegment | undefined {\n    return this.segments.get(name);\n  }\n\n  /**\n   * Get all segments\n   */\n  getAllSegments(): readonly OptionalSegment[] {\n    return this.orderedSegments;\n  }\n\n  /**\n   * Get configuration\n   */\n  getConfig(): Readonly<OptionalRouteBuilderConfig> {\n    return this.config;\n  }\n\n  /**\n   * Build regex pattern for matching\n   */\n  private buildPattern(): RegExp {\n    const basePath = this.config.basePath.replace(/\\/$/, '');\n    const escapedBase = basePath.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n    // Each optional segment can be present or not\n    const segmentPatterns = this.orderedSegments\n      .map(() => '(?:/([^/]+))?');\n\n    const fullPattern = `^${escapedBase}${segmentPatterns.join('')}/?$`;\n    return new RegExp(fullPattern);\n  }\n}\n\n// =============================================================================\n// OptionalSegmentManager Class\n// =============================================================================\n\n/**\n * Manages multiple optional segment routes\n */\nexport class OptionalSegmentManager {\n  private routes: Map<string, OptionalSegmentRouteBuilder> = new Map();\n  private idCounter = 0;\n\n  /**\n   * Register a route with optional segments\n   *\n   * @param config - Route configuration\n   * @returns Route ID\n   */\n  register(config: OptionalRouteBuilderConfig): string {\n    const id = `optional_${++this.idCounter}`;\n    const route = new OptionalSegmentRouteBuilder(config);\n    this.routes.set(id, route);\n    return id;\n  }\n\n  /**\n   * Unregister a route\n   *\n   * @param id - Route ID\n   * @returns True if route was found and removed\n   */\n  unregister(id: string): boolean {\n    return this.routes.delete(id);\n  }\n\n  /**\n   * Find best matching route for a path\n   *\n   * @param path - URL path\n   * @returns Best match or null\n   */\n  findBestMatch(path: string): {\n    route: OptionalSegmentRouteBuilder;\n    match: OptionalRouteMatch;\n    id: string;\n  } | null {\n    const matches: Array<{\n      route: OptionalSegmentRouteBuilder;\n      match: OptionalRouteMatch;\n      id: string;\n    }> = [];\n\n    for (const [id, route] of this.routes) {\n      const match = route.match(path);\n      if (match.matches) {\n        matches.push({ route, match, id });\n      }\n    }\n\n    if (matches.length === 0) {\n      return null;\n    }\n\n    // Sort by score (descending)\n    matches.sort((a, b) => b.match.score - a.match.score);\n\n    return matches[0] ?? null;\n  }\n\n  /**\n   * Get all registered routes\n   */\n  getAllRoutes(): readonly { id: string; route: OptionalSegmentRouteBuilder }[] {\n    return Array.from(this.routes.entries()).map(([id, route]) => ({ id, route }));\n  }\n\n  /**\n   * Get a specific route\n   */\n  getRoute(id: string): OptionalSegmentRouteBuilder | undefined {\n    return this.routes.get(id);\n  }\n\n  /**\n   * Clear all routes\n   */\n  clearAll(): void {\n    this.routes.clear();\n  }\n}\n\n// =============================================================================\n// Factory Functions\n// =============================================================================\n\n/**\n * Create an optional segment configuration\n *\n * @param config - Segment configuration\n * @returns OptionalSegment instance\n */\nexport function createOptionalSegment<T = string>(\n  config: OptionalSegmentConfig<T>\n): OptionalSegment<T> {\n  return new OptionalSegment(config);\n}\n\n/**\n * Create a route with optional segments\n *\n * @param config - Route configuration\n * @returns OptionalSegmentRouteBuilder instance\n */\nexport function createOptionalRoute(\n  config: OptionalRouteBuilderConfig\n): OptionalSegmentRouteBuilder {\n  return new OptionalSegmentRouteBuilder(config);\n}\n\n/**\n * Create a pagination optional segment\n *\n * @param options - Options\n * @returns Configured OptionalSegment for pagination\n */\nexport function createPaginationSegment(options: {\n  name?: string;\n  defaultPage?: number;\n  maxPage?: number;\n} = {}): OptionalSegment<number> {\n  const maxPage = options.maxPage ?? 1000;\n\n  return new OptionalSegment({\n    name: options.name ?? 'page',\n    defaultValue: options.defaultPage ?? 1,\n    transform: (v) => parseInt(v, 10),\n    validate: (v) => {\n      const num = parseInt(v, 10);\n      return !isNaN(num) && num >= 1 && num <= maxPage;\n    },\n    description: `Page number (1-${maxPage})`,\n  });\n}\n\n/**\n * Create a category filter optional segment\n *\n * @param categories - Allowed categories\n * @param defaultCategory - Default category\n * @returns Configured OptionalSegment for categories\n */\nexport function createCategorySegment(\n  categories: readonly string[],\n  defaultCategory: string\n): OptionalSegment {\n  return new OptionalSegment({\n    name: 'category',\n    defaultValue: defaultCategory,\n    allowedValues: categories,\n    description: `Category filter (${categories.join(', ')})`,\n  });\n}\n\n/**\n * Create a sort order optional segment\n *\n * @param options - Sort options\n * @returns Configured OptionalSegment for sorting\n */\nexport function createSortSegment(options: {\n  allowedValues?: readonly string[];\n  defaultValue?: string;\n} = {}): OptionalSegment {\n  return new OptionalSegment({\n    name: 'sort',\n    defaultValue: options.defaultValue ?? 'default',\n    allowedValues: options.allowedValues ?? ['default', 'newest', 'oldest', 'popular', 'price-asc', 'price-desc'],\n    description: 'Sort order',\n  });\n}\n\n// =============================================================================\n// Singleton Instance\n// =============================================================================\n\nlet defaultManager: OptionalSegmentManager | null = null;\n\n/**\n * Get the default optional segment manager\n */\nexport function getOptionalSegmentManager(): OptionalSegmentManager {\n  defaultManager ??= new OptionalSegmentManager();\n  return defaultManager;\n}\n\n/**\n * Reset the default optional segment manager\n */\nexport function resetOptionalSegmentManager(): void {\n  defaultManager?.clearAll();\n  defaultManager = null;\n}\n\n// =============================================================================\n// Utility Functions\n// =============================================================================\n\n/**\n * Check if a pattern contains optional segments\n *\n * @param pattern - Route pattern\n * @returns True if pattern has optional segments\n */\nexport function hasOptionalSegments(pattern: string): boolean {\n  return /\\[\\[[^\\]]+\\]\\]/.test(pattern);\n}\n\n/**\n * Extract optional segment names from a pattern\n *\n * @param pattern - Route pattern\n * @returns Array of optional segment names\n */\nexport function extractOptionalSegmentNames(pattern: string): string[] {\n  const matches = pattern.match(/\\[\\[([^\\]]+)\\]\\]/g) ?? [];\n  return matches.map(m => m.slice(2, -2)); // Remove [[ and ]]\n}\n\n/**\n * Convert pattern with optional segments to regex-friendly pattern\n *\n * @param pattern - Route pattern with optional segments\n * @returns Pattern suitable for regex\n */\nexport function normalizeOptionalPattern(pattern: string): string {\n  return pattern.replace(/\\[\\[([^\\]]+)\\]\\]/g, '(?:([^/]+))?');\n}\n\n/**\n * Build all possible paths for a route with optional segments\n *\n * @param basePath - Base path\n * @param segments - Optional segment configs\n * @returns Array of all possible path combinations\n */\nexport function buildAllPossiblePaths(\n  basePath: string,\n  segments: readonly OptionalSegmentConfig[]\n): string[] {\n  const paths: string[] = [basePath.replace(/\\/$/, '')];\n\n  // Generate all combinations\n  const generateCombinations = (index: number, currentPath: string): void => {\n    if (index >= segments.length) return;\n\n    const segment = segments[index];\n    if (segment === undefined) return;\n    const defaultValue = String(segment.defaultValue);\n\n    // Path with this segment's default\n    const pathWithSegment = `${currentPath}/${defaultValue}`;\n    paths.push(pathWithSegment);\n\n    // Continue with remaining segments\n    generateCombinations(index + 1, pathWithSegment);\n  };\n\n  generateCombinations(0, basePath.replace(/\\/$/, ''));\n\n  return paths;\n}\n\n// =============================================================================\n// Type Guards\n// =============================================================================\n\n/**\n * Type guard for OptionalSegmentResolution\n */\nexport function isOptionalSegmentResolution<T>(\n  value: unknown\n): value is OptionalSegmentResolution<T> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'present' in value &&\n    'value' in value &&\n    'valid' in value\n  );\n}\n\n/**\n * Type guard for OptionalRouteMatch\n */\nexport function isOptionalRouteMatch(value: unknown): value is OptionalRouteMatch {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'matches' in value &&\n    'values' in value &&\n    'presentSegments' in value\n  );\n}\n"],"names":["OptionalSegment","config","value","transformed","OptionalSegmentRouteBuilder","segConfig","segment","path","match","values","presentSegments","defaultedSegments","errors","i","rawValue","resolution","score","options","parts","defaultValue","stringValue","basePath","segmentPatterns","s","name","escapedBase","fullPattern","OptionalSegmentManager","id","route","matches","a","b","createOptionalSegment","defaultManager","getOptionalSegmentManager","resetOptionalSegmentManager"],"mappings":"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"}