@tnotesjs/core 0.6.1 → 0.7.0

package/dist/vitepress/config/index.js

@@ -1,19 +1,20 @@
 import {
   FileWatcherService,
   NoteIndexCache,
-  NoteService,
+  ROOT_DIR_PATH,
   RenameNoteCommand,
-  TocService,
   UpdateNoteConfigCommand,
   logger
-} from "../../chunk-DUTS75WQ.js";
+} from "../../chunk-XNO3PCEH.js";
 import {
   ConfigManager
 } from "../../chunk-UJG3UU5X.js";
-import "../../chunk-U6IBLREL.js";
+import {
+  createWorkspace
+} from "../../chunk-ZEQS64PE.js";
 import {
   generateAnchor
-} from "../../chunk-CZXRQPFJ.js";
+} from "../../chunk-GWG75A5M.js";
 
 // vitepress/config/index.ts
 import fs3 from "fs";
@@ -1249,21 +1250,8 @@ function normalizeCount(value) {
   }
   return count;
 }
-function getCreatedNotePayload(notes) {
-  return notes.map((note) => ({
-    index: note.index,
-    dirName: note.dirName,
-    link: `/notes/${encodeURIComponent(note.dirName)}/README`
-  }));
-}
-function buildNoteReadmeLink(note) {
-  return `/notes/${encodeURIComponent(note.dirName)}/README`;
-}
-function resolveDeleteRedirectUrl(noteService, previousNoteIndex) {
-  if (!previousNoteIndex) return "/";
-  const previousNote = noteService.getNoteByIndex(previousNoteIndex);
-  if (!previousNote) return "/";
-  return buildNoteReadmeLink(previousNote);
+function buildNoteReadmeLink(dirName) {
+  return `/notes/${encodeURIComponent(dirName)}/README`;
 }
 async function withSuspendedWatcher(task) {
   const watcher = FileWatcherService.getInstance();
@@ -1274,33 +1262,78 @@ async function withSuspendedWatcher(task) {
     watcher?.unsuspend();
   }
 }
-function sidebarStructurePlugin() {
-  const noteService = NoteService.getInstance();
-  const tocService = TocService.getInstance();
-  async function createNotes(count) {
-    const notes = [];
-    const usedIndexes = /* @__PURE__ */ new Set();
-    for (const note of noteService.getAllNotes()) {
-      const index = parseInt(note.index, 10);
-      if (!isNaN(index)) {
-        usedIndexes.add(index);
+function collectRefs(snapshot) {
+  const byLine = /* @__PURE__ */ new Map();
+  const orderedIndexes = [];
+  let order = 0;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "folder") {
+        walk(node.children);
+        continue;
       }
-    }
-    for (let i = 0; i < count; i++) {
-      const note = await noteService.createNote({
-        title: "new",
-        usedIndexes
+      const subtree = [];
+      const collect = (n) => {
+        if (n.kind === "note") subtree.push(n.noteIndex);
+        for (const child of n.children) collect(child);
+      };
+      collect(node);
+      byLine.set(node.tocLineIndex, {
+        tocLineIndex: node.tocLineIndex,
+        ref: { type: "note", noteUuid: "" },
+        subtreeIndexes: subtree,
+        orderIndex: order
       });
-      const index = parseInt(note.index, 10);
-      if (!isNaN(index)) {
-        usedIndexes.add(index);
-      }
-      notes.push(note);
+      orderedIndexes.push(...subtree);
+      order += 1;
     }
-    return notes;
+  };
+  walk(snapshot.toc);
+  return { byLine, orderedIndexes };
+}
+function noteUuidForIndex(snapshot, index) {
+  const note = snapshot.notes.find((item) => item.index === index);
+  if (!note) throw new Error(`\u672A\u627E\u5230\u7B14\u8BB0: ${index}`);
+  return note.uuid;
+}
+function previousNoteIndex(snapshot, entry) {
+  if (!entry) return null;
+  const entries = [...collectRefs(snapshot).byLine.values()].sort(
+    (a, b) => a.orderIndex - b.orderIndex
+  );
+  let cursor = 0;
+  for (const item of entries) {
+    if (item === entry) return cursor > 0 ? collectRefs(snapshot).orderedIndexes[cursor - 1] : null;
+    cursor += item.subtreeIndexes.length;
   }
+  return null;
+}
+function isNoteInSubtree(snapshot, lineIndex, noteIndex) {
+  const entry = collectRefs(snapshot).byLine.get(lineIndex);
+  return entry ? entry.subtreeIndexes.includes(noteIndex) : false;
+}
+function folderPathAtLine(snapshot, lineIndex) {
+  const result = [];
+  const walk = (nodes, path6) => {
+    for (const node of nodes) {
+      if (node.kind === "folder") {
+        if (node.tocLineIndex === lineIndex) {
+          result.push(...[...path6, node.title]);
+          return true;
+        }
+        if (walk(node.children, [...path6, node.title])) return true;
+      }
+    }
+    return false;
+  };
+  walk(snapshot.toc, []);
+  if (result.length === 0) throw new Error(`\u672A\u627E\u5230\u76EE\u5F55\u884C: ${lineIndex}`);
+  return result;
+}
+function sidebarStructurePlugin() {
+  const workspace = createWorkspace({ rootPath: ROOT_DIR_PATH });
   async function refreshTocAndSidebar() {
-    await tocService.regenerateSidebar();
+    await workspace.toc.reconcileFromFiles();
   }
   return {
     name: "tnotes-sidebar-structure",
@@ -1327,22 +1360,27 @@ function sidebarStructurePlugin() {
         try {
           const data = await readJsonBody(req);
           const result = await withSuspendedWatcher(async () => {
+            const snapshot = await workspace.inspect();
             if (pathname === "/__tnotes_sidebar_delete_note") {
               const noteIndex = String(data.noteIndex || "");
               if (!noteIndex) throw new Error("Missing noteIndex");
-              const previousNoteIndex = await tocService.getPreviousNoteIndexBeforeDelete(noteIndex);
-              await tocService.deleteNoteFromToc(noteIndex);
-              await noteService.deleteNote(noteIndex);
+              const refs = collectRefs(snapshot);
+              const deletedRef = [...refs.byLine.values()].find(
+                (item) => item.subtreeIndexes.includes(noteIndex)
+              );
+              const previous = previousNoteIndex(snapshot, deletedRef);
+              await workspace.toc.deleteEntry({
+                entry: { type: "note", noteUuid: noteUuidForIndex(snapshot, noteIndex) },
+                expectedSnapshotRevision: snapshot.revision
+              });
               await refreshTocAndSidebar();
               scheduleNoteSearchReindex("api:delete-note");
+              const redirectDir = previous ? snapshot.notes.find((item) => item.index === previous)?.dirName : void 0;
               return {
                 success: true,
                 sidebarChanged: true,
-                redirectUrl: resolveDeleteRedirectUrl(
-                  noteService,
-                  previousNoteIndex
-                ),
-                redirectNoteIndex: previousNoteIndex,
+                redirectUrl: redirectDir ? buildNoteReadmeLink(redirectDir) : "/",
+                redirectNoteIndex: previous,
                 deletedNoteIndexes: [noteIndex],
                 message: "\u7B14\u8BB0\u5DF2\u5220\u9664"
               };
@@ -1353,22 +1391,26 @@ function sidebarStructurePlugin() {
                 throw new Error("Missing tocLineIndex");
               }
               const currentNoteIndex = String(data.currentNoteIndex || "");
-              const previousNoteIndex = await tocService.getPreviousNoteIndexBeforeEntryDelete(
+              const inSubtree = currentNoteIndex ? isNoteInSubtree(snapshot, tocLineIndex, currentNoteIndex) : false;
+              const entry = collectRefs(snapshot).byLine.get(tocLineIndex);
+              const previous = previousNoteIndex(snapshot, entry);
+              const preview = await workspace.toc.previewDelete({
+                type: "line",
                 tocLineIndex
-              );
-              const inSubtree = currentNoteIndex && await tocService.isNoteInTocEntrySubtree(
-                tocLineIndex,
-                currentNoteIndex
-              );
-              const deletedNoteIndexes = await tocService.deleteTocEntryCascade(tocLineIndex);
+              });
+              await workspace.toc.deleteEntry({
+                entry: { type: "line", tocLineIndex },
+                expectedSnapshotRevision: snapshot.revision
+              });
               await refreshTocAndSidebar();
               scheduleNoteSearchReindex("api:delete-entry");
+              const redirectDir = inSubtree && previous ? snapshot.notes.find((item) => item.index === previous)?.dirName : void 0;
               return {
                 success: true,
                 sidebarChanged: true,
-                redirectUrl: inSubtree ? resolveDeleteRedirectUrl(noteService, previousNoteIndex) : void 0,
-                redirectNoteIndex: inSubtree ? previousNoteIndex : null,
-                deletedNoteIndexes,
+                redirectUrl: redirectDir ? buildNoteReadmeLink(redirectDir) : void 0,
+                redirectNoteIndex: inSubtree ? previous : null,
+                deletedNoteIndexes: preview.notes.map((note) => note.index),
                 message: "\u5DF2\u5220\u9664"
               };
             }
@@ -1378,7 +1420,11 @@ function sidebarStructurePlugin() {
               if (!Number.isInteger(tocLineIndex) || tocLineIndex < 0) {
                 throw new Error("Missing tocLineIndex");
               }
-              await tocService.renameFolderInToc(tocLineIndex, newTitle);
+              await workspace.toc.renameGroup({
+                folderPath: folderPathAtLine(snapshot, tocLineIndex),
+                title: newTitle,
+                expectedSnapshotRevision: snapshot.revision
+              });
               await refreshTocAndSidebar();
               return {
                 success: true,
@@ -1387,8 +1433,20 @@ function sidebarStructurePlugin() {
               };
             }
             if (pathname === "/__tnotes_sidebar_reorder") {
-              if (data.node_uuid && data.action === "prependChild" && !data.target_uuid) {
-                await tocService.prependToRootByNodeId(String(data.node_uuid));
+              const awaitMove = async (source2, target, placement2) => {
+                await workspace.toc.move({
+                  source: source2,
+                  target,
+                  placement: placement2,
+                  expectedSnapshotRevision: snapshot.revision
+                });
+              };
+              if (typeof data.node_uuid === "string" && data.action === "prependChild" && !data.target_uuid) {
+                await awaitMove(
+                  { type: "note", noteUuid: data.node_uuid },
+                  { type: "line", tocLineIndex: 0 },
+                  data.placement === "after" ? "after" : "before"
+                );
                 await refreshTocAndSidebar();
                 return {
                   success: true,
@@ -1396,18 +1454,12 @@ function sidebarStructurePlugin() {
                   message: "\u6392\u5E8F\u5DF2\u66F4\u65B0"
                 };
               }
-              if (data.node_uuid && data.target_uuid && (data.action === "moveAfter" || data.action === "prependChild")) {
-                if (data.action === "moveAfter") {
-                  await tocService.moveAfterByNodeId(
-                    String(data.node_uuid),
-                    String(data.target_uuid)
-                  );
-                } else {
-                  await tocService.prependChildByNodeId(
-                    String(data.node_uuid),
-                    String(data.target_uuid)
-                  );
-                }
+              if (typeof data.node_uuid === "string" && typeof data.target_uuid === "string" && (data.action === "moveAfter" || data.action === "prependChild")) {
+                await awaitMove(
+                  { type: "note", noteUuid: data.node_uuid },
+                  { type: "note", noteUuid: data.target_uuid },
+                  data.action === "prependChild" ? "inside" : "after"
+                );
                 await refreshTocAndSidebar();
                 return {
                   success: true,
@@ -1420,27 +1472,32 @@ function sidebarStructurePlugin() {
                 throw new Error("Missing dragTocLineIndex");
               }
               const placement = data.targetType === "group" || data.placement === "inside" ? "inside" : data.placement === "after" ? "after" : "before";
+              const source = { type: "line", tocLineIndex: dragTocLineIndex };
               if (data.targetTocLineIndex !== void 0 && data.targetTocLineIndex !== null) {
-                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
-                  targetTocLineIndex: Number(data.targetTocLineIndex),
+                await awaitMove(
+                  source,
+                  { type: "line", tocLineIndex: Number(data.targetTocLineIndex) },
                   placement
-                });
+                );
               } else if (Array.isArray(data.targetFolderPath) && data.targetFolderPath.length > 0) {
-                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
-                  targetType: "folder",
-                  targetFolderPath: data.targetFolderPath.map(String),
+                await awaitMove(
+                  source,
+                  {
+                    type: "folder",
+                    folderPath: data.targetFolderPath.map(String)
+                  },
                   placement
-                });
+                );
               } else {
-                const targetNoteIndex = String(
+                const targetNoteIndex2 = String(
                   data.targetNoteIndex || data.targetGroupNoteIndex || ""
                 );
-                if (!targetNoteIndex) throw new Error("Missing targetNoteIndex");
-                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
-                  targetType: "note",
-                  targetNoteIndex,
+                if (!targetNoteIndex2) throw new Error("Missing targetNoteIndex");
+                await awaitMove(
+                  source,
+                  { type: "note", noteUuid: noteUuidForIndex(snapshot, targetNoteIndex2) },
                   placement
-                });
+                );
               }
               await refreshTocAndSidebar();
               return {
@@ -1455,10 +1512,13 @@ function sidebarStructurePlugin() {
               if (!Number.isInteger(parentTocLineIndex) || parentTocLineIndex < 0) {
                 throw new Error("Missing parentTocLineIndex");
               }
-              await tocService.insertFolderUnderParent(
-                parentTocLineIndex,
-                title
-              );
+              const sibling = collectRefs(snapshot).byLine.get(parentTocLineIndex);
+              if (!sibling) throw new Error("\u672A\u627E\u5230\u76EE\u5F55\u884C");
+              await workspace.toc.createGroup({
+                title,
+                placement: sibling.ref.type === "note" ? { type: "note", targetNoteUuid: sibling.ref.noteUuid, placement: "inside" } : { type: "root", placement: "end" },
+                expectedSnapshotRevision: snapshot.revision
+              });
               await refreshTocAndSidebar();
               return {
                 success: true,
@@ -1467,40 +1527,48 @@ function sidebarStructurePlugin() {
               };
             }
             const count = normalizeCount(data.count);
-            const notes = await createNotes(count);
-            if (data.targetNoteIndex) {
-              const placement = data.placement === "after" ? "after" : "before";
-              await tocService.insertNotesAroundNote(
-                String(data.targetNoteIndex),
-                notes,
-                placement
-              );
-            } else if (data.parentTocLineIndex !== void 0 && data.parentTocLineIndex !== null) {
-              await tocService.insertNotesUnderTocLine(
-                Number(data.parentTocLineIndex),
-                notes
-              );
-            } else if (Array.isArray(data.parentFolderPath) && data.parentFolderPath.length > 0) {
-              await tocService.insertNotesUnderFolder(
-                data.parentFolderPath.map(String),
-                notes
-              );
-            } else if (data.parentNoteIndex) {
-              await tocService.insertNotesUnderParent(
-                String(data.parentNoteIndex),
-                notes
-              );
-            } else {
-              for (const note of notes) {
-                await tocService.appendNoteToToc(note.index);
+            const targetNoteIndex = String(
+              data.targetNoteIndex || data.targetGroupNoteIndex || ""
+            );
+            const parentLine = data.parentTocLineIndex !== void 0 && data.parentTocLineIndex !== null ? Number(data.parentTocLineIndex) : null;
+            const created = [];
+            for (let i = 0; i < count; i++) {
+              let placement;
+              if (targetNoteIndex) {
+                placement = {
+                  type: "note",
+                  targetNoteUuid: noteUuidForIndex(snapshot, targetNoteIndex),
+                  placement: data.placement === "after" ? "after" : "before"
+                };
+              } else if (parentLine !== null) {
+                const sibling = collectRefs(snapshot).byLine.get(parentLine);
+                if (sibling && sibling.ref.type === "note") {
+                  placement = {
+                    type: "note",
+                    targetNoteUuid: sibling.ref.noteUuid,
+                    placement: "inside"
+                  };
+                }
               }
+              const result2 = await workspace.notes.create({
+                title: "new",
+                placement,
+                expectedSnapshotRevision: snapshot.revision
+              });
+              created.push({
+                index: result2.value.index,
+                dirName: result2.value.dirName
+              });
             }
             await refreshTocAndSidebar();
             scheduleNoteSearchReindex("api:create-notes");
             return {
               success: true,
               sidebarChanged: true,
-              createdNotes: getCreatedNotePayload(notes),
+              createdNotes: created.map((note) => ({
+                ...note,
+                link: buildNoteReadmeLink(note.dirName)
+              })),
               message: "\u7B14\u8BB0\u5DF2\u521B\u5EFA"
             };
           });