index.js

// PERF: Pre-created handler functions to reduce closure overhead
// These are reused across all route registrations
const updateParamsHandler = (req, res, params) => {
  req.params = params
  return true
}
const noParamsHandler = () => true
const defaultHandler = () => false

// PERF: Router cache for reusing router instances (WeakMap + Map for multi-level caching)
const routerCache = new WeakMap()

// PERF: Normalized endpoint cache to avoid re-normalizing identical endpoints
// Maps endpoint objects to their normalized form
const normalizedCache = new WeakMap()

// PERF: Optimized endpoint normalization with caching
// Reuses normalized endpoints to avoid repeated object creation
function normalizeEndpoint (endpoint) {
  if (typeof endpoint === 'string') {
    return { url: endpoint, methods: ['GET'], updateParams: false }
  }

  // Check if we've already normalized this endpoint object
  if (typeof endpoint === 'object' && endpoint !== null) {
    const cached = normalizedCache.get(endpoint)
    if (cached) return cached

    const normalized = {
      methods: endpoint.methods || ['GET'],
      url: endpoint.url,
      version: endpoint.version,
      updateParams: endpoint.updateParams || false
    }

    // Cache the normalized form for future use
    normalizedCache.set(endpoint, normalized)
    return normalized
  }

  return {
    methods: endpoint.methods || ['GET'],
    url: endpoint.url,
    version: endpoint.version,
    updateParams: endpoint.updateParams || false
  }
}

module.exports = function (routerOpts = {}, routerFactory = require('find-my-way')) {
  function exec (options, isIff = true) {
    const middleware = this
    let router = null
    let customFn = null

    // PERF: Optimized option processing with early type checking
    // Reduces repeated property access and type checks
    if (typeof options === 'function') {
      customFn = options
    } else if (options) {
      // PERF: Extract endpoints with single property access
      const endpoints = Array.isArray(options) ? options : options.endpoints

      if (endpoints && endpoints.length > 0) {
        // PERF: Try to get cached router first
        let cache = routerCache.get(routerOpts)
        if (!cache) {
          cache = new Map()
          routerCache.set(routerOpts, cache)
        }

        // Cache key must serialize the full endpoint list: partial keys
        // collide and silently reuse a router built for different routes
        const cacheKey = JSON.stringify(endpoints)
        router = cache.get(cacheKey)

        if (!router) {
          router = routerFactory({ ...routerOpts, defaultRoute: defaultHandler })

          // PERF: Normalize and register routes with optimized normalization
          // Reuses normalized endpoints from cache when possible
          const normalized = endpoints.map(normalizeEndpoint)
          for (const { methods, url, version, updateParams } of normalized) {
            // PERF: Use pre-created handler functions instead of closures
            // Reduces memory allocations and improves cache locality
            const handler = updateParams ? updateParamsHandler : noParamsHandler

            if (version) {
              router.on(methods, url, { constraints: { version } }, handler)
            } else {
              router.on(methods, url, handler)
            }
          }

          cache.set(cacheKey, router)
        }
      }

      // PERF: Check custom function with single property access
      if (options.custom) {
        customFn = options.custom
      }
    }

    // PERF: Optimized execution function with minimal overhead
    // Uses early returns and pre-computed handler functions
    const result = function (req, res, next) {
      let shouldExecute = false

      if (customFn) {
        // PERF: Custom functions are fastest path (no router overhead)
        shouldExecute = customFn(req)
      } else if (router) {
        // PERF: Router lookup is cached by find-my-way internally
        shouldExecute = router.lookup(req, res)
      }

      // PERF: Simplified logic with early return (reduces branch prediction misses)
      // XOR-like logic: execute if (iff && shouldExecute) OR (!iff && !shouldExecute)
      if ((isIff && shouldExecute) || (!isIff && !shouldExecute)) {
        return middleware(req, res, next)
      }

      return next()
    }

    // Allow chaining
    result.iff = iff
    result.unless = unless

    return result
  }

  function iff (options) {
    return exec.call(this, options, true)
  }
  function unless (options) {
    return exec.call(this, options, false)
  }

  return function (middleware) {
    middleware.iff = iff
    middleware.unless = unless

    return middleware
  }
}