code optimisation for circular ref issue

lib/dereference.js

@@ -14,10 +14,18 @@ module.exports = dereference;
  * @param {$RefParser} parser
  * @param {$RefParserOptions} options
  */
-function dereference (parser, options) {
+async function dereference(parser, options) {
   parser.$refs.propertyMap = {}; // we assign a new object prior to another dereference process
   // console.log('Dereferencing $ref pointers in %s', parser.$refs._root$Ref.path);
-  let dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, "#", [], {}, parser.$refs, options);
+  let dereferenced = await crawl(
+    parser.schema,
+    parser.$refs._root$Ref.path,
+    "#",
+    [],
+    {},
+    parser.$refs,
+    options
+  );
   parser.$refs.circular = dereferenced.circular;
   parser.schema = dereferenced.value;
 }
@@ -34,46 +42,75 @@ function dereference (parser, options) {
  * @param {$RefParserOptions} options
  * @returns {{value: object, circular: boolean}}
  */
-function crawl (obj, path, pathFromRoot, parents, dereferencedCache, $refs, options) {
+async function crawl(
+  obj,
+  path,
+  pathFromRoot,
+  parents,
+  dereferencedCache,
+  $refs,
+  options
+) {
   let dereferenced;
   let result = {
     value: obj,
-    circular: false
+    circular: false,
   };
 
   if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj)) {
     parents.push(obj);
 
     if ($Ref.isAllowed$Ref(obj, options)) {
-      dereferenced = dereference$Ref(obj, path, pathFromRoot, parents, dereferencedCache, $refs, options);
+      dereferenced = await dereference$Ref(
+        obj,
+        path,
+        pathFromRoot,
+        parents,
+        dereferencedCache,
+        $refs,
+        options
+      );
       result.circular = dereferenced.circular;
       result.value = dereferenced.value;
-    }
-    else {
+    } else {
       for (let key of Object.keys(obj)) {
         let keyPath = Pointer.join(path, key);
         let keyPathFromRoot = Pointer.join(pathFromRoot, key);
         let value = obj[key];
         let circular = false;
 
         if ($Ref.isAllowed$Ref(value, options)) {
-          dereferenced = dereference$Ref(value, keyPath, keyPathFromRoot, parents, dereferencedCache, $refs, options);
+          dereferenced = await dereference$Ref(
+            value,
+            keyPath,
+            keyPathFromRoot,
+            parents,
+            dereferencedCache,
+            $refs,
+            options
+          );
           circular = dereferenced.circular;
           // Avoid pointless mutations; breaks frozen objects to no profit
           if (obj[key] !== dereferenced.value) {
             obj[key] = dereferenced.value;
           }
-        }
-        else {
+        } else {
           if (parents.indexOf(value) === -1) {
-            dereferenced = crawl(value, keyPath, keyPathFromRoot, parents, dereferencedCache, $refs, options);
+            dereferenced = await crawl(
+              value,
+              keyPath,
+              keyPathFromRoot,
+              parents,
+              dereferencedCache,
+              $refs,
+              options
+            );
             circular = dereferenced.circular;
             // Avoid pointless mutations; breaks frozen objects to no profit
             if (obj[key] !== dereferenced.value) {
               obj[key] = dereferenced.value;
             }
-          }
-          else {
+          } else {
             circular = foundCircularReference(keyPath, $refs, options);
           }
         }
@@ -101,7 +138,15 @@ function crawl (obj, path, pathFromRoot, parents, dereferencedCache, $refs, opti
  * @param {$RefParserOptions} options
  * @returns {{value: object, circular: boolean}}
  */
-function dereference$Ref ($ref, path, pathFromRoot, parents, dereferencedCache, $refs, options) {
+async function dereference$Ref(
+  $ref,
+  path,
+  pathFromRoot,
+  parents,
+  dereferencedCache,
+  $refs,
+  options
+) {
   // console.log('Dereferencing $ref pointer "%s" at %s', $ref.$ref, path);
 
   let $refPath = url.resolve(path, $ref.$ref);
@@ -147,12 +192,24 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, dereferencedCache,
   // Crawl the dereferenced value (unless it's circular)
   if (!circular) {
     // Determine if the dereferenced value is circular
-    let dereferenced = crawl(dereferencedValue, pointer.path, pathFromRoot, parents, dereferencedCache, $refs, options);
+    let dereferenced = await crawl(
+      dereferencedValue,
+      pointer.path,
+      pathFromRoot,
+      parents,
+      dereferencedCache,
+      $refs,
+      options
+    );
     circular = dereferenced.circular;
     dereferencedValue = dereferenced.value;
   }
 
-  if (circular && !directCircular && options.dereference.circular === "ignore") {
+  if (
+    circular &&
+    !directCircular &&
+    options.dereference.circular === "ignore"
+  ) {
     // The user has chosen to "ignore" circular references, so don't change the value
     dereferencedValue = $ref;
   }
@@ -165,7 +222,7 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, dereferencedCache,
 
   const dereferencedObject = {
     circular,
-    value: dereferencedValue
+    value: dereferencedValue,
   };
 
   // only cache if no extra properties than $ref
@@ -185,7 +242,7 @@ function dereference$Ref ($ref, path, pathFromRoot, parents, dereferencedCache,
  * @param {$RefParserOptions} options
  * @returns {boolean} - always returns true, to indicate that a circular reference was found
  */
-function foundCircularReference (keyPath, $refs, options) {
+function foundCircularReference(keyPath, $refs, options) {
   $refs.circular = true;
   if (!options.dereference.circular) {
     throw ono.reference(`Circular $ref pointer found at ${keyPath}`);