From f7c4fe4a6d406bf70e2eded74d138ada16247da1 Mon Sep 17 00:00:00 2001
From: Ross Keenan <rossk29@gmail.com>
Date: Tue, 14 Dec 2021 07:28:12 +0200
Subject: [PATCH] fix(DendronNote): :bug: Don't return if g.hasNode. It may
 already have it from other means

---
 main.js     | 40 +++++++++++++++++++++++++++++++++++-----
 src/main.ts | 43 +++++++++++++++++++++++++++++++++++++++----
 2 files changed, 74 insertions(+), 9 deletions(-)

diff --git a/main.js b/main.js
index 554c11bb..0c12d52c 100644
--- a/main.js
+++ b/main.js
@@ -52061,14 +52061,13 @@ class BCPlugin extends require$$0.Plugin {
         const { addDendronNotes, dendronNoteDelimiter, dendronNoteField } = this.settings;
         if (!addDendronNotes)
             return;
-        frontms.forEach((frontm) => {
+        for (const frontm of frontms) {
             const { file } = frontm;
             const basename = getDVBasename(file);
-            if (mainG.hasNode(basename))
-                return;
             const splits = basename.split(dendronNoteDelimiter);
             if (splits.length < 2)
-                return;
+                continue;
+            // Probably inefficient to reverse then unreverse it. I can probably just use slice(-i)
             const reversed = splits.reverse();
             reversed.forEach((split, i) => {
                 const currSlice = reversed
@@ -52085,7 +52084,38 @@ class BCPlugin extends require$$0.Plugin {
                 const targetOrder = this.getTargetOrder(frontms, nextSlice);
                 this.populateMain(mainG, currSlice, dendronNoteField, nextSlice, sourceOrder, targetOrder, true);
             });
-        });
+        }
+        // frontms.forEach((frontm) => {
+        //   const { file } = frontm;
+        //   const basename = getDVBasename(file);
+        //   // It could have the node from another means already, but that doesn't mean it should return...
+        //   // if (mainG.hasNode(basename)) return;
+        //   const splits = basename.split(dendronNoteDelimiter);
+        //   if (splits.length < 2) return;
+        //   const reversed = splits.reverse();
+        //   reversed.forEach((split, i) => {
+        //     const currSlice = reversed
+        //       .slice(i)
+        //       .reverse()
+        //       .join(dendronNoteDelimiter);
+        //     const nextSlice = reversed
+        //       .slice(i + 1)
+        //       .reverse()
+        //       .join(dendronNoteDelimiter);
+        //     if (!nextSlice) return;
+        //     const sourceOrder = this.getSourceOrder(frontm);
+        //     const targetOrder = this.getTargetOrder(frontms, nextSlice);
+        //     this.populateMain(
+        //       mainG,
+        //       currSlice,
+        //       dendronNoteField,
+        //       nextSlice,
+        //       sourceOrder,
+        //       targetOrder,
+        //       true
+        //     );
+        //   });
+        // });
     }
     async initGraphs() {
         const mainG = new graphology_umd_min.MultiGraph();
diff --git a/src/main.ts b/src/main.ts
index bbbfb564..a4a9c133 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -1033,14 +1033,14 @@ export default class BCPlugin extends Plugin {
       this.settings;
     if (!addDendronNotes) return;
 
-    frontms.forEach((frontm) => {
+    for (const frontm of frontms) {
       const { file } = frontm;
       const basename = getDVBasename(file);
-      if (mainG.hasNode(basename)) return;
 
       const splits = basename.split(dendronNoteDelimiter);
-      if (splits.length < 2) return;
+      if (splits.length < 2) continue;
 
+      // Probably inefficient to reverse then unreverse it. I can probably just use slice(-i)
       const reversed = splits.reverse();
       reversed.forEach((split, i) => {
         const currSlice = reversed
@@ -1066,7 +1066,42 @@ export default class BCPlugin extends Plugin {
           true
         );
       });
-    });
+    }
+    // frontms.forEach((frontm) => {
+    //   const { file } = frontm;
+    //   const basename = getDVBasename(file);
+    //   // It could have the node from another means already, but that doesn't mean it should return...
+    //   // if (mainG.hasNode(basename)) return;
+
+    //   const splits = basename.split(dendronNoteDelimiter);
+    //   if (splits.length < 2) return;
+
+    //   const reversed = splits.reverse();
+    //   reversed.forEach((split, i) => {
+    //     const currSlice = reversed
+    //       .slice(i)
+    //       .reverse()
+    //       .join(dendronNoteDelimiter);
+    //     const nextSlice = reversed
+    //       .slice(i + 1)
+    //       .reverse()
+    //       .join(dendronNoteDelimiter);
+    //     if (!nextSlice) return;
+
+    //     const sourceOrder = this.getSourceOrder(frontm);
+    //     const targetOrder = this.getTargetOrder(frontms, nextSlice);
+
+    //     this.populateMain(
+    //       mainG,
+    //       currSlice,
+    //       dendronNoteField,
+    //       nextSlice,
+    //       sourceOrder,
+    //       targetOrder,
+    //       true
+    //     );
+    //   });
+    // });
   }
 
   getTargetOrder = (frontms: dvFrontmatterCache[], target: string) =>