@trojs/openapi-dereference 1.0.1 → 1.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@trojs/openapi-dereference",
     "description": "OpenAPI dereference",
-    "version": "1.0.1",
+    "version": "1.1.0",
     "author": {
         "name": "Pieter Wigboldus",
         "url": "https://trojs.org/"
@@ -12,8 +12,8 @@
         "lint:report": "eslint src/*.js -f json -o report.json",
         "lint:fix": "eslint --fix",
         "lint:rules": "eslint --print-config file.js > eslintconfig.json",
-        "test": "c8 node --test src/*.test.js",
-        "test:watch": "c8 node --watch --test src/*.test.js",
+        "test": "node --test --experimental-test-coverage --test-reporter=spec --test-reporter=lcov --test-reporter-destination=stdout --test-reporter-destination=./coverage/lcov.info",
+        "test:watch": "node --watch --test --experimental-test-coverage --test-reporter=spec --test-reporter=lcov --test-reporter-destination=stdout --test-reporter-destination=./coverage/lcov.info",
         "cpd": "node_modules/jscpd/bin/jscpd src",
         "vulnerabilities": "npm audit --omit=dev"
     },
@@ -28,19 +28,9 @@
     "main": "src/index.js",
     "types": "src/types.d.ts",
     "devDependencies": {
-        "@eslint/js": "^9.15.0",
-        "@stylistic/eslint-plugin": "^2.11.0",
-        "@stylistic/eslint-plugin-js": "^2.11.0",
-        "c8": "^10.0.0",
+        "@trojs/lint": "^0.2.13",
         "eslint": "^9.15.0",
-        "eslint-config-prettier": "^10.0.0",
-        "eslint-plugin-import": "^2.31.0",
-        "eslint-plugin-jsdoc": "^50.5.0",
-        "eslint-plugin-n": "^17.15.1",
-        "eslint-plugin-prettier": "^5.2.1",
-        "eslint-plugin-promise": "^7.1.0",
-        "eslint-plugin-sonarjs": "^2.0.4",
-        "globals": "^15.12.0",
+        "globals": "^16.0.0",
         "jscpd": "^4.0.0",
         "json-schema": "^0.4.0"
     },

package/src/dereference.js

@@ -17,46 +17,46 @@ const cache = new Map()
  * @returns {DereferencedJSONSchema}
  */
 export const dereferenceSync = (schema) => {
-    if (cache.has(schema)) {
-        return cache.get(schema)
-    }
+  if (cache.has(schema)) {
+    return cache.get(schema)
+  }
 
-    const visitedNodes = new Set()
-    const cloned = klona(schema)
-
-    const resolve = (current, path) => {
-        if (typeof current === 'object' && current !== null) {
-            // make sure we don't visit the same node twice
-            if (visitedNodes.has(current)) {
-                return current
-            }
-            visitedNodes.add(current)
-
-            if (Array.isArray(current)) {
-                // array
-                for (let index = 0; index < current.length; index++) {
-                    current[index] = resolve(current[index], `${path}/${index}`)
-                }
-            } else {
-                // object
-                if ('$ref' in current && typeof current.$ref === 'string') {
-                    let ref = current
-                    do {
-                        ref = resolveRefSync(cloned, ref.$ref)
-                    } while (ref?.$ref)
-                    return ref
-                }
-
-                for (const key in current) {
-                    current[key] = resolve(current[key], `${path}/${key}`)
-                }
-            }
-        }
+  const visitedNodes = new Set()
+  const cloned = klona(schema)
 
+  const resolve = (current, path) => {
+    if (typeof current === 'object' && current !== null) {
+      // make sure we don't visit the same node twice
+      if (visitedNodes.has(current)) {
         return current
+      }
+      visitedNodes.add(current)
+
+      if (Array.isArray(current)) {
+        // array
+        for (let index = 0; index < current.length; index++) {
+          current[index] = resolve(current[index], `${path}/${index}`)
+        }
+      } else {
+        // object
+        if ('$ref' in current && typeof current.$ref === 'string') {
+          let ref = current
+          do {
+            ref = resolveRefSync(cloned, ref.$ref)
+          } while (ref?.$ref)
+          return ref
+        }
+
+        for (const key in current) {
+          current[key] = resolve(current[key], `${path}/${key}`)
+        }
+      }
     }
 
-    const result = resolve(cloned, '#')
-    cache.set(schema, result)
-    return result
+    return current
+  }
+
+  const result = resolve(cloned, '#')
+  cache.set(schema, result)
+  return result
 }

package/src/klona.js

@@ -9,30 +9,30 @@
  * @returns {any}
  */
 export function klona (val) {
-    let index, out, tmp
+  let index, out, tmp
 
-    if (Array.isArray(val)) {
-        out = Array((index = val.length))
-        while (index--) out[index] = (tmp = val[index]) && typeof tmp === 'object' ? klona(tmp) : tmp
-        return out
-    }
+  if (Array.isArray(val)) {
+    out = Array((index = val.length))
+    while (index--) out[index] = (tmp = val[index]) && typeof tmp === 'object' ? klona(tmp) : tmp
+    return out
+  }
 
-    if (Object.prototype.toString.call(val) === '[object Object]') {
-        out = {} // null
-        for (index in val) {
-            if (index === '__proto__') {
-                Object.defineProperty(out, index, {
-                    value: klona(val[index]),
-                    configurable: true,
-                    enumerable: true,
-                    writable: true
-                })
-            } else {
-                out[index] = (tmp = val[index]) && typeof tmp === 'object' ? klona(tmp) : tmp
-            }
-        }
-        return out
+  if (Object.prototype.toString.call(val) === '[object Object]') {
+    out = {} // null
+    for (index in val) {
+      if (index === '__proto__') {
+        Object.defineProperty(out, index, {
+          value: klona(val[index]),
+          configurable: true,
+          enumerable: true,
+          writable: true
+        })
+      } else {
+        out[index] = (tmp = val[index]) && typeof tmp === 'object' ? klona(tmp) : tmp
+      }
     }
+    return out
+  }
 
-    return val
+  return val
 }

package/src/resolveRef.js

@@ -12,26 +12,26 @@ const cache = new Map()
  * @returns {unknown}
  */
 export const resolveRefSync = (schema, ref) => {
-    if (!cache.has(schema)) {
-        cache.set(schema, new Map())
-    }
-    const schemaCache = cache.get(schema)
+  if (!cache.has(schema)) {
+    cache.set(schema, new Map())
+  }
+  const schemaCache = cache.get(schema)
 
-    if (schemaCache.has(ref)) {
-        return schemaCache.get(ref)
-    }
+  if (schemaCache.has(ref)) {
+    return schemaCache.get(ref)
+  }
 
-    const path = ref.split('/').slice(1)
+  const path = ref.split('/').slice(1)
 
-    let current = schema
-    for (const segment of path) {
-        if (!current || typeof current !== 'object') {
-            // we've reached a dead end
-            current = null
-        }
-        current = current[segment] ?? null
+  let current = schema
+  for (const segment of path) {
+    if (!current || typeof current !== 'object') {
+      // we've reached a dead end
+      current = null
     }
+    current = current[segment] ?? null
+  }
 
-    schemaCache.set(ref, current)
-    return current
+  schemaCache.set(ref, current)
+  return current
 }