@tnotesjs/core 0.1.28 → 0.2.1

package/dist/vitepress/config/index.js

@@ -2,19 +2,19 @@ import {
   FileWatcherService,
   NoteIndexCache,
   NoteService,
-  ReadmeService,
   RenameNoteCommand,
+  TocService,
   UpdateNoteConfigCommand,
   generateAnchor,
   logger
-} from "../../chunk-4KG6RXFS.js";
+} from "../../chunk-5QN44ES5.js";
 import {
   ConfigManager
-} from "../../chunk-AGSL3VZE.js";
+} from "../../chunk-5Y5IYS6C.js";
 
 // vitepress/config/index.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path5 from "path";
 import { defineConfig } from "vitepress";
 
 // vitepress/configs/constants.ts
@@ -764,6 +764,422 @@ function getNoteByConfigIdPlugin() {
   };
 }
 
+// vitepress/plugins/localSearchReindexPlugin.ts
+import path4 from "path";
+
+// vitepress/plugins/localSearchIndexBuilder.ts
+import MiniSearch from "minisearch";
+import fs2 from "fs/promises";
+import path3 from "path";
+import {
+  createMarkdownRenderer,
+  resolvePages
+} from "vitepress";
+
+// vitepress/plugins/localSearchReindexLogic.ts
+import path2 from "path";
+function slash(value) {
+  return value.replace(/\\/g, "/");
+}
+var NOTE_README_RE = /(?:^|[\\/])notes[\\/](\d{4}\.[^\\/]+)[\\/]README\.md$/i;
+function isNoteReadmePath(filePath, ignoreDirNames = []) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = NOTE_README_RE.exec(normalized);
+  if (!match) return false;
+  const folderName = match[1];
+  if (!folderName) return false;
+  return !ignoreDirNames.some((dir) => folderName === dir);
+}
+function getDocIdFromFile(input) {
+  const absoluteFile = path2.isAbsolute(input.absoluteOrRelativeFile) ? input.absoluteOrRelativeFile : path2.join(input.srcDir, input.absoluteOrRelativeFile);
+  let relFile = slash(path2.relative(input.srcDir, absoluteFile));
+  if (input.rewrites?.[relFile]) {
+    relFile = input.rewrites[relFile];
+  }
+  let id = slash(path2.posix.join(input.base, relFile));
+  id = id.replace(/(^|\/)index\.md$/, "$1");
+  id = id.replace(/\.md$/, input.cleanUrls ? "" : ".html");
+  return id;
+}
+
+// vitepress/plugins/localSearchIndexBuilder.ts
+var headingRegex = /<h(\d*).*?>(.*?<a.*? href="#.*?".*?>.*?<\/a>)<\/h\1>/gi;
+var headingContentRegex = /(.*?)<a.*? href="#(.*?)".*?>.*?<\/a>/i;
+function slash2(value) {
+  return value.replace(/\\/g, "/");
+}
+function clearHtmlTags(str) {
+  return str.replace(/<[^>]*>/g, "");
+}
+function getSearchableText(content) {
+  return clearHtmlTags(content);
+}
+function* splitPageIntoSections(html) {
+  const result = html.split(headingRegex);
+  result.shift();
+  let parentTitles = [];
+  for (let i = 0; i < result.length; i += 3) {
+    const level = parseInt(result[i], 10) - 1;
+    const heading = result[i + 1];
+    const headingResult = headingContentRegex.exec(heading);
+    const title = clearHtmlTags(headingResult?.[1] ?? "").trim();
+    const anchor = headingResult?.[2] ?? "";
+    const content = result[i + 2];
+    if (!title || !content) continue;
+    let titles = parentTitles.slice(0, level);
+    titles[level] = title;
+    titles = titles.filter(Boolean);
+    yield { anchor, titles, text: getSearchableText(content) };
+    if (level === 0) {
+      parentTitles = [title];
+    } else {
+      parentTitles[level] = title;
+    }
+  }
+}
+function getLocaleForPath(site, page) {
+  const normalizedPage = slash2(page);
+  for (const [localePath, localeConfig] of Object.entries(site.locales ?? {})) {
+    const prefix = localePath.replace(/\\/g, "/");
+    if (prefix === "root") continue;
+    const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+    if (normalizedPage.startsWith(normalizedPrefix)) {
+      return localePath;
+    }
+    if (localeConfig?.lang && normalizedPage === prefix.replace(/\/$/, "")) {
+      return localePath;
+    }
+  }
+  return "root";
+}
+async function createLocalSearchMarkdownRenderer(siteConfig) {
+  return createMarkdownRenderer(
+    siteConfig.srcDir,
+    siteConfig.markdown,
+    siteConfig.site.base,
+    siteConfig.logger
+  );
+}
+async function renderPageHtml(siteConfig, md, absoluteFile) {
+  if (!await fs2.stat(absoluteFile).catch(() => null)) return "";
+  const srcDir = siteConfig.srcDir;
+  const relativePath = slash2(path3.relative(srcDir, absoluteFile));
+  const env = {
+    path: absoluteFile,
+    relativePath,
+    cleanUrls: siteConfig.cleanUrls ?? false,
+    frontmatter: {}
+  };
+  const options = siteConfig.site.themeConfig?.search?.options ?? {};
+  const mdRaw = await fs2.readFile(absoluteFile, "utf-8");
+  if (options._render) {
+    return await options._render(mdRaw, env, md);
+  }
+  const html = md.render(mdRaw, env);
+  return env.frontmatter?.search === false ? "" : html;
+}
+async function indexPage(siteConfig, md, page, index) {
+  const absoluteFile = path3.join(siteConfig.srcDir, page);
+  const fileId = getDocIdFromFile({
+    srcDir: siteConfig.srcDir,
+    base: siteConfig.site.base,
+    cleanUrls: siteConfig.cleanUrls ?? false,
+    rewrites: siteConfig.rewrites.map,
+    absoluteOrRelativeFile: absoluteFile
+  });
+  const html = await renderPageHtml(siteConfig, md, absoluteFile);
+  const sections = splitPageIntoSections(html);
+  for (const section of sections) {
+    if (!section || !(section.text || section.titles)) break;
+    const { anchor, text, titles } = section;
+    const id = anchor ? [fileId, anchor].join("#") : fileId;
+    if (index.has(id)) index.discard(id);
+    index.add({
+      id,
+      text,
+      title: titles[titles.length - 1],
+      titles: titles.slice(0, -1)
+    });
+  }
+}
+async function buildLocalSearchIndexSnapshot(siteConfig, md) {
+  const { pages } = await resolvePages(
+    siteConfig.srcDir,
+    siteConfig.userConfig,
+    siteConfig.logger
+  );
+  const options = siteConfig.site.themeConfig?.search?.options ?? {};
+  const indexByLocale = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const locale = getLocaleForPath(siteConfig.site, page);
+    let index = indexByLocale.get(locale);
+    if (!index) {
+      index = new MiniSearch({
+        fields: ["title", "titles", "text"],
+        storeFields: ["title", "titles"],
+        ...options.miniSearch?.options
+      });
+      indexByLocale.set(locale, index);
+    }
+    await indexPage(siteConfig, md, page, index);
+  }
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const [locale, index] of indexByLocale) {
+    snapshot.set(locale, JSON.stringify(JSON.stringify(index)));
+  }
+  return { snapshot, pageCount: pages.length };
+}
+
+// vitepress/plugins/localSearchReindexPatch.ts
+function patchVPNavBarSearch(code) {
+  if (code.includes("localSearchIndexBridge")) return null;
+  if (!code.includes("VPLocalSearchBox")) return null;
+  let next = code.replace(
+    /<script lang="ts" setup>\r?\n/,
+    `<script lang="ts" setup>
+import { searchBoxRemountKey } from '@tnotesjs/core/vitepress/client/localSearchIndexBridge'
+`
+  );
+  next = next.replace(
+    /<VPLocalSearchBox\r?\n\s+v-if="showSearch"\r?\n\s+@close="showSearch = false"\r?\n\s+\/>/,
+    `<VPLocalSearchBox
+        v-if="showSearch"
+        :key="searchBoxRemountKey"
+        @close="showSearch = false"
+      />`
+  );
+  return next === code ? null : next;
+}
+
+// vitepress/plugins/localSearchReindexPlugin.ts
+var LOCAL_SEARCH_INDEX_REQUEST_PATH = "/@localSearchIndex";
+var LOCAL_SEARCH_INDEX_ID = "@localSearchIndex";
+var SEARCH_REINDEX_HTTP_PATH = "/__tnotes_search_reindex";
+var SEARCH_INDEX_HMR_EVENT = "tnotes:search-index-updated";
+var REBUILD_DEBOUNCE_MS = 400;
+var VP_NAV_BAR_SEARCH = /vitepress[/\\]dist[/\\]client[/\\]theme-default[/\\]components[/\\]VPNavBarSearch\.vue$/;
+var reindexController = null;
+var indexSnapshot = null;
+var snapshotRevision = 0;
+var DEBUG = process.env.TNOTES_DEBUG_SEARCH_REINDEX === "1";
+function debugLog(message, detail) {
+  if (!DEBUG) return;
+  if (detail === void 0) {
+    console.log(`[tnotes:search-reindex] ${message}`);
+    return;
+  }
+  console.log(`[tnotes:search-reindex] ${message}`, detail);
+}
+function logInfo(message) {
+  console.warn(`[tnotes:search-reindex] ${message}`);
+}
+function normalizeId(id) {
+  return id.replace(/\\/g, "/");
+}
+function getVitePressSiteConfig(server) {
+  return server.config.vitepress ?? null;
+}
+function isLocalSearchEnabled(server) {
+  return server.config.plugins.some(
+    (entry) => entry.name === "vitepress:local-search" && typeof entry.load === "function"
+  );
+}
+function normalizeLocalSearchModuleId(id) {
+  return id.split("?")[0];
+}
+function getLocaleFromIndexModuleId(id) {
+  const normalized = normalizeLocalSearchModuleId(id);
+  if (normalized === LOCAL_SEARCH_INDEX_REQUEST_PATH) return null;
+  if (!normalized.startsWith(LOCAL_SEARCH_INDEX_REQUEST_PATH)) return null;
+  return normalized.slice(LOCAL_SEARCH_INDEX_REQUEST_PATH.length) || null;
+}
+function getSearchIndexModuleIds(snapshot) {
+  const ids = [LOCAL_SEARCH_INDEX_REQUEST_PATH];
+  for (const locale of snapshot.keys()) {
+    ids.push(`${LOCAL_SEARCH_INDEX_REQUEST_PATH}${locale}`);
+  }
+  return ids;
+}
+function notifySearchIndexUpdated(server, snapshot, revision) {
+  const moduleIds = getSearchIndexModuleIds(snapshot);
+  const updates = [];
+  for (const moduleId of moduleIds) {
+    server.moduleGraph.onFileChange(moduleId);
+    const mod = server.moduleGraph.getModuleById(moduleId);
+    if (mod) {
+      server.moduleGraph.invalidateModule(mod);
+      updates.push({
+        acceptedPath: mod.url,
+        path: mod.url,
+        timestamp: Date.now(),
+        type: "js-update"
+      });
+      continue;
+    }
+    debugLog(`HMR module not loaded yet: ${moduleId}`);
+  }
+  if (updates.length > 0) {
+    server.ws.send({ type: "update", updates });
+    debugLog("HMR pushed", updates.map((item) => item.path));
+  } else {
+    debugLog("HMR skipped: no loaded search index modules");
+  }
+  server.ws.send({
+    type: "custom",
+    event: SEARCH_INDEX_HMR_EVENT,
+    data: { revision }
+  });
+  debugLog("custom HMR event sent", { revision });
+}
+function renderSnapshotLoad(id, snapshot) {
+  const normalizedId = normalizeLocalSearchModuleId(id);
+  if (normalizedId === LOCAL_SEARCH_INDEX_REQUEST_PATH) {
+    const records = [];
+    for (const locale2 of snapshot.keys()) {
+      records.push(
+        `${JSON.stringify(locale2)}: () => import('${LOCAL_SEARCH_INDEX_ID}${locale2}')`
+      );
+    }
+    return `export default {${records.join(",")}}`;
+  }
+  const locale = getLocaleFromIndexModuleId(id);
+  if (locale !== null) {
+    const payload = snapshot.get(locale) ?? JSON.stringify({});
+    return `export default ${payload}`;
+  }
+  return null;
+}
+function createDebouncer(delayMs) {
+  let timer = null;
+  let pendingReason = "";
+  return (reason, task) => {
+    pendingReason = reason;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(async () => {
+      timer = null;
+      const reasonToRun = pendingReason;
+      pendingReason = "";
+      try {
+        await task();
+      } catch (error) {
+        console.error(
+          `[tnotes:search-reindex] rebuild failed (${reasonToRun})`,
+          error
+        );
+      }
+    }, delayMs);
+  };
+}
+function matchesSearchReindexPath(url) {
+  return url === SEARCH_REINDEX_HTTP_PATH || url.endsWith(SEARCH_REINDEX_HTTP_PATH);
+}
+function scheduleNoteSearchReindex(reason = "external") {
+  if (!reindexController) {
+    logInfo(`schedule ignored (plugin not ready): ${reason}`);
+    return;
+  }
+  reindexController.schedule(reason);
+}
+function localSearchReindexPlugin() {
+  return {
+    name: "tnotes-local-search-reindex",
+    apply: "serve",
+    enforce: "pre",
+    resolveId(source) {
+      if (!source.startsWith(LOCAL_SEARCH_INDEX_ID)) return null;
+      const clean = source.split("?")[0];
+      if (clean === source) return null;
+      return `/${clean}`;
+    },
+    transform(code, id) {
+      const normalizedId = normalizeId(id);
+      if (VP_NAV_BAR_SEARCH.test(normalizedId)) {
+        return patchVPNavBarSearch(code);
+      }
+      return null;
+    },
+    load(id) {
+      if (!indexSnapshot || !id.startsWith(LOCAL_SEARCH_INDEX_REQUEST_PATH)) {
+        return null;
+      }
+      return renderSnapshotLoad(id, indexSnapshot);
+    },
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        const url = req.url ?? "";
+        if (!matchesSearchReindexPath(url) || req.method !== "POST") {
+          return next();
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const data = JSON.parse(body || "{}");
+            scheduleNoteSearchReindex(data.reason || "bridge:http");
+            res.statusCode = 204;
+            res.end();
+          } catch (error) {
+            res.statusCode = 400;
+            res.end(
+              error instanceof Error ? error.message : "Bad search reindex payload"
+            );
+          }
+        });
+      });
+      return async () => {
+        indexSnapshot = null;
+        snapshotRevision = 0;
+        if (!isLocalSearchEnabled(server)) {
+          reindexController = null;
+          logInfo("vitepress:local-search not found, reindex disabled");
+          return;
+        }
+        const siteConfig = getVitePressSiteConfig(server);
+        if (!siteConfig) {
+          reindexController = null;
+          logInfo("server.config.vitepress missing, reindex disabled");
+          return;
+        }
+        ConfigManager.init({ rootPath: process.cwd() });
+        const ignoreDirNames = ConfigManager.getInstance().getAll().ignore_dirs ?? [];
+        const md = await createLocalSearchMarkdownRenderer(siteConfig);
+        const debouncedRebuild = createDebouncer(REBUILD_DEBOUNCE_MS);
+        async function rebuildFullIndex(reason) {
+          const startedAt = Date.now();
+          snapshotRevision += 1;
+          debugLog(`rebuild start (${reason}) rev=${snapshotRevision}`);
+          const { snapshot, pageCount } = await buildLocalSearchIndexSnapshot(
+            siteConfig,
+            md
+          );
+          indexSnapshot = snapshot;
+          notifySearchIndexUpdated(server, indexSnapshot, snapshotRevision);
+          logInfo(
+            `rebuild done (${reason}) rev=${snapshotRevision} pages=${pageCount} locales=${indexSnapshot.size} elapsed=${Date.now() - startedAt}ms`
+          );
+        }
+        reindexController = {
+          schedule(reason) {
+            debugLog(`scheduled (${reason})`);
+            debouncedRebuild(reason, () => rebuildFullIndex(reason));
+          }
+        };
+        const onWatcherEvent = (absoluteFile, event) => {
+          if (!isNoteReadmePath(absoluteFile, ignoreDirNames)) return;
+          scheduleNoteSearchReindex(
+            `watcher:${event}:${path4.basename(absoluteFile)}`
+          );
+        };
+        server.watcher.on("add", (file) => onWatcherEvent(file, "add"));
+        server.watcher.on("change", (file) => onWatcherEvent(file, "change"));
+        server.watcher.on("unlink", (file) => onWatcherEvent(file, "unlink"));
+      };
+    }
+  };
+}
+
 // vitepress/plugins/renameNotePlugin.ts
 function renameNotePlugin() {
   const renameCommand = new RenameNoteCommand();
@@ -836,12 +1252,6 @@ function sendJson(res, statusCode, payload) {
 function normalizePathname(url) {
   return (url || "").split("?")[0];
 }
-function normalizeGroupPath(value) {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error("Missing groupPath");
-  }
-  return value.map((item) => String(item));
-}
 function normalizeCount(value) {
   const count = Number(value ?? 1);
   if (!Number.isInteger(count) || count < 1 || count > 100) {
@@ -856,6 +1266,15 @@ function getCreatedNotePayload(notes) {
     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);
+}
 async function withSuspendedWatcher(task) {
   const watcher = FileWatcherService.getInstance();
   try {
@@ -867,7 +1286,7 @@ async function withSuspendedWatcher(task) {
 }
 function sidebarStructurePlugin() {
   const noteService = NoteService.getInstance();
-  const readmeService = ReadmeService.getInstance();
+  const tocService = TocService.getInstance();
   async function createNotes(count) {
     const notes = [];
     const usedIndexes = /* @__PURE__ */ new Set();
@@ -890,17 +1309,21 @@ function sidebarStructurePlugin() {
     }
     return notes;
   }
+  async function refreshTocAndSidebar() {
+    await tocService.regenerateSidebar();
+  }
   return {
     name: "tnotes-sidebar-structure",
     configureServer(server) {
       server.middlewares.use(async (req, res, next) => {
         const pathname = normalizePathname(req.url);
         const handledPaths = /* @__PURE__ */ new Set([
-          "/__tnotes_sidebar_rename_group",
-          "/__tnotes_sidebar_delete_group",
           "/__tnotes_sidebar_create_note",
           "/__tnotes_sidebar_create_notes",
+          "/__tnotes_sidebar_create_folder",
           "/__tnotes_sidebar_delete_note",
+          "/__tnotes_sidebar_delete_entry",
+          "/__tnotes_sidebar_rename_folder",
           "/__tnotes_sidebar_reorder"
         ]);
         if (!handledPaths.has(pathname)) {
@@ -914,92 +1337,176 @@ function sidebarStructurePlugin() {
         try {
           const data = await readJsonBody(req);
           const result = await withSuspendedWatcher(async () => {
-            if (pathname === "/__tnotes_sidebar_rename_group") {
-              const groupPath = normalizeGroupPath(data.groupPath);
-              const newTitle = String(data.newTitle || "");
-              await readmeService.renameGroupInReadme(groupPath, newTitle);
-              await readmeService.refreshHomeReadmeAndSidebar();
+            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);
+              await refreshTocAndSidebar();
+              scheduleNoteSearchReindex("api:delete-note");
               return {
                 success: true,
                 sidebarChanged: true,
-                message: "\u76EE\u5F55\u5DF2\u91CD\u547D\u540D"
+                redirectUrl: resolveDeleteRedirectUrl(
+                  noteService,
+                  previousNoteIndex
+                ),
+                redirectNoteIndex: previousNoteIndex,
+                deletedNoteIndexes: [noteIndex],
+                message: "\u7B14\u8BB0\u5DF2\u5220\u9664"
               };
             }
-            if (pathname === "/__tnotes_sidebar_delete_group") {
-              const groupPath = normalizeGroupPath(data.groupPath);
-              const noteIndexes = await readmeService.deleteGroupFromReadme(
-                groupPath
-              );
-              for (const noteIndex of noteIndexes) {
-                await noteService.deleteNote(noteIndex);
+            if (pathname === "/__tnotes_sidebar_delete_entry") {
+              const tocLineIndex = Number(data.tocLineIndex);
+              if (!Number.isInteger(tocLineIndex) || tocLineIndex < 0) {
+                throw new Error("Missing tocLineIndex");
               }
-              await readmeService.refreshHomeReadmeAndSidebar();
+              const currentNoteIndex = String(data.currentNoteIndex || "");
+              const previousNoteIndex = await tocService.getPreviousNoteIndexBeforeEntryDelete(
+                tocLineIndex
+              );
+              const inSubtree = currentNoteIndex && await tocService.isNoteInTocEntrySubtree(
+                tocLineIndex,
+                currentNoteIndex
+              );
+              const deletedNoteIndexes = await tocService.deleteTocEntryCascade(tocLineIndex);
+              await refreshTocAndSidebar();
+              scheduleNoteSearchReindex("api:delete-entry");
               return {
                 success: true,
                 sidebarChanged: true,
-                redirectUrl: "/",
-                deletedNoteIndexes: noteIndexes,
-                message: "\u76EE\u5F55\u5DF2\u5220\u9664"
+                redirectUrl: inSubtree ? resolveDeleteRedirectUrl(noteService, previousNoteIndex) : void 0,
+                redirectNoteIndex: inSubtree ? previousNoteIndex : null,
+                deletedNoteIndexes,
+                message: "\u5DF2\u5220\u9664"
               };
             }
-            if (pathname === "/__tnotes_sidebar_delete_note") {
-              const noteIndex = String(data.noteIndex || "");
-              if (!noteIndex) throw new Error("Missing noteIndex");
-              await readmeService.deleteNoteFromReadme(noteIndex);
-              await noteService.deleteNote(noteIndex);
-              await readmeService.refreshHomeReadmeAndSidebar();
+            if (pathname === "/__tnotes_sidebar_rename_folder") {
+              const tocLineIndex = Number(data.tocLineIndex);
+              const newTitle = String(data.newTitle || "");
+              if (!Number.isInteger(tocLineIndex) || tocLineIndex < 0) {
+                throw new Error("Missing tocLineIndex");
+              }
+              await tocService.renameFolderInToc(tocLineIndex, newTitle);
+              await refreshTocAndSidebar();
               return {
                 success: true,
                 sidebarChanged: true,
-                redirectUrl: "/",
-                deletedNoteIndexes: [noteIndex],
-                message: "\u7B14\u8BB0\u5DF2\u5220\u9664"
+                message: "\u76EE\u5F55\u5DF2\u91CD\u547D\u540D"
               };
             }
             if (pathname === "/__tnotes_sidebar_reorder") {
-              if (data.dragType === "note") {
-                const noteIndex = String(data.noteIndex || "");
-                if (!noteIndex) throw new Error("Missing noteIndex");
-                if (data.targetType === "group") {
-                  await readmeService.moveNoteInReadme(noteIndex, {
-                    targetGroupPath: normalizeGroupPath(data.targetGroupPath)
-                  });
+              if (data.node_uuid && data.action === "prependChild" && !data.target_uuid) {
+                await tocService.prependToRootByNodeId(String(data.node_uuid));
+                await refreshTocAndSidebar();
+                return {
+                  success: true,
+                  sidebarChanged: true,
+                  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 readmeService.moveNoteInReadme(noteIndex, {
-                    targetNoteIndex: String(data.targetNoteIndex || ""),
-                    placement: data.placement === "after" ? "after" : "before"
-                  });
+                  await tocService.prependChildByNodeId(
+                    String(data.node_uuid),
+                    String(data.target_uuid)
+                  );
                 }
-              } else if (data.dragType === "group") {
-                await readmeService.moveGroupInReadme(
-                  normalizeGroupPath(data.groupPath),
-                  normalizeGroupPath(data.targetGroupPath),
-                  data.placement === "after" ? "after" : "before"
-                );
+                await refreshTocAndSidebar();
+                return {
+                  success: true,
+                  sidebarChanged: true,
+                  message: "\u6392\u5E8F\u5DF2\u66F4\u65B0"
+                };
+              }
+              const dragTocLineIndex = Number(data.dragTocLineIndex);
+              if (!Number.isInteger(dragTocLineIndex) || dragTocLineIndex < 0) {
+                throw new Error("Missing dragTocLineIndex");
+              }
+              const placement = data.targetType === "group" || data.placement === "inside" ? "inside" : data.placement === "after" ? "after" : "before";
+              if (data.targetTocLineIndex !== void 0 && data.targetTocLineIndex !== null) {
+                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
+                  targetTocLineIndex: 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),
+                  placement
+                });
               } else {
-                throw new Error("Missing dragType");
+                const targetNoteIndex = String(
+                  data.targetNoteIndex || data.targetGroupNoteIndex || ""
+                );
+                if (!targetNoteIndex) throw new Error("Missing targetNoteIndex");
+                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
+                  targetType: "note",
+                  targetNoteIndex,
+                  placement
+                });
               }
-              await readmeService.refreshHomeReadmeAndSidebar();
+              await refreshTocAndSidebar();
               return {
                 success: true,
                 sidebarChanged: true,
                 message: "\u6392\u5E8F\u5DF2\u66F4\u65B0"
               };
             }
+            if (pathname === "/__tnotes_sidebar_create_folder") {
+              const parentTocLineIndex = Number(data.parentTocLineIndex);
+              const title = String(data.title || "");
+              if (!Number.isInteger(parentTocLineIndex) || parentTocLineIndex < 0) {
+                throw new Error("Missing parentTocLineIndex");
+              }
+              await tocService.insertFolderUnderParent(
+                parentTocLineIndex,
+                title
+              );
+              await refreshTocAndSidebar();
+              return {
+                success: true,
+                sidebarChanged: true,
+                message: "\u76EE\u5F55\u5DF2\u521B\u5EFA"
+              };
+            }
             const count = normalizeCount(data.count);
             const notes = await createNotes(count);
             if (data.targetNoteIndex) {
               const placement = data.placement === "after" ? "after" : "before";
-              await readmeService.insertNotesAroundNote(
+              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 {
-              const groupPath = normalizeGroupPath(data.groupPath);
-              await readmeService.insertNotesAtGroupStart(groupPath, notes);
+              for (const note of notes) {
+                await tocService.appendNoteToToc(note.index);
+              }
             }
-            await readmeService.refreshHomeReadmeAndSidebar();
+            await refreshTocAndSidebar();
+            scheduleNoteSearchReindex("api:create-notes");
             return {
               success: true,
               sidebarChanged: true,
@@ -1105,6 +1612,7 @@ function defineNotesConfig(overrides = {}) {
         sidebarStructurePlugin(),
         getNoteByConfigIdPlugin(),
         fileWatcherBridgePlugin(),
+        localSearchReindexPlugin(),
         ...overrideVite?.plugins || []
       ],
       server: {
@@ -1153,9 +1661,9 @@ function defineNotesConfig(overrides = {}) {
     },
     transformPageData(pageData, ctx) {
       if (/^notes\/\d{4}/.test(pageData.relativePath)) {
-        const fullPath = path2.resolve(rootPath, pageData.relativePath);
+        const fullPath = path5.resolve(rootPath, pageData.relativePath);
         try {
-          const raw = fs2.readFileSync(fullPath, "utf-8");
+          const raw = fs3.readFileSync(fullPath, "utf-8");
           pageData.frontmatter.rawContent = Buffer.from(raw, "utf-8").toString(
             "base64"
           );