style: format code for consistency and readability

Author: jkyberneees

index.js

@@ -2,111 +2,111 @@
 const createMatchHandler = (updateParams) =>
   updateParams
     ? (req, res, params) => {
-        req.params = params;
-        return true;
+        req.params = params
+        return true
       }
-    : () => true;
+    : () => true
 
-const defaultHandler = () => false;
+const defaultHandler = () => false
 
 // Router cache for reusing router instances
-const routerCache = new WeakMap();
+const routerCache = new WeakMap()
 
-function normalizeEndpoint(endpoint) {
-  if (typeof endpoint === "string") {
-    return { url: endpoint, methods: ["GET"], updateParams: false };
+function normalizeEndpoint (endpoint) {
+  if (typeof endpoint === 'string') {
+    return { url: endpoint, methods: ['GET'], updateParams: false }
   }
   return {
-    methods: endpoint.methods || ["GET"],
+    methods: endpoint.methods || ['GET'],
     url: endpoint.url,
     version: endpoint.version,
-    updateParams: endpoint.updateParams || false,
-  };
+    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;
+module.exports = function (routerOpts = {}, routerFactory = require('find-my-way')) {
+  function exec (options, isIff = true) {
+    const middleware = this
+    let router = null
+    let customFn = null
 
     // Process options efficiently
-    if (typeof options === "function") {
-      customFn = options;
+    if (typeof options === 'function') {
+      customFn = options
     } else {
-      const endpoints = Array.isArray(options) ? options : options?.endpoints;
+      const endpoints = Array.isArray(options) ? options : options?.endpoints
 
       if (endpoints?.length) {
         // Try to get cached router first
-        let cache = routerCache.get(routerOpts);
+        let cache = routerCache.get(routerOpts)
         if (!cache) {
-          cache = new Map();
-          routerCache.set(routerOpts, cache);
+          cache = new Map()
+          routerCache.set(routerOpts, cache)
         }
 
-        const cacheKey = JSON.stringify(endpoints);
-        router = cache.get(cacheKey);
+        const cacheKey = JSON.stringify(endpoints)
+        router = cache.get(cacheKey)
 
         if (!router) {
-          router = routerFactory({ ...routerOpts, defaultRoute: defaultHandler });
+          router = routerFactory({ ...routerOpts, defaultRoute: defaultHandler })
 
           // Normalize and register routes
-          const normalized = endpoints.map(normalizeEndpoint);
+          const normalized = endpoints.map(normalizeEndpoint)
           for (const { methods, url, version, updateParams } of normalized) {
-            const handler = createMatchHandler(updateParams);
+            const handler = createMatchHandler(updateParams)
 
             if (version) {
-              router.on(methods, url, { constraints: { version } }, handler);
+              router.on(methods, url, { constraints: { version } }, handler)
             } else {
-              router.on(methods, url, handler);
+              router.on(methods, url, handler)
             }
           }
 
-          cache.set(cacheKey, router);
+          cache.set(cacheKey, router)
         }
       }
 
       if (options?.custom) {
-        customFn = options.custom;
+        customFn = options.custom
       }
     }
 
     // Optimized execution function
     const result = function (req, res, next) {
-      let shouldExecute = false;
+      let shouldExecute = false
 
       if (customFn) {
-        shouldExecute = customFn(req);
+        shouldExecute = customFn(req)
       } else if (router) {
-        shouldExecute = router.lookup(req, res);
+        shouldExecute = router.lookup(req, res)
       }
 
       // Simplified logic: execute middleware if conditions match
       if ((isIff && shouldExecute) || (!isIff && !shouldExecute)) {
-        return middleware(req, res, next);
+        return middleware(req, res, next)
       }
 
-      return next();
-    };
+      return next()
+    }
 
     // Allow chaining
-    result.iff = iff;
-    result.unless = unless;
+    result.iff = iff
+    result.unless = unless
 
-    return result;
+    return result
   }
 
-  function iff(options) {
-    return exec.call(this, options, true);
+  function iff (options) {
+    return exec.call(this, options, true)
   }
-  function unless(options) {
-    return exec.call(this, options, false);
+  function unless (options) {
+    return exec.call(this, options, false)
   }
 
   return function (middleware) {
-    middleware.iff = iff;
-    middleware.unless = unless;
+    middleware.iff = iff
+    middleware.unless = unless
 
-    return middleware;
-  };
-};
+    return middleware
+  }
+}