gatsby-source-notion-churnotion 1.2.6 → 1.2.8

package/dist/util/resolvers.js

@@ -26,108 +26,131 @@ const formatTableOfContents = (tableOfContents, reporter) => {
                 entry.contextTitle = entry.title;
             }
         }
-        // 1. Find all main headings (h1)
-        const mainHeadings = sortedToc.filter((entry) => entry.level === 1);
-        // 2. Find all command headings (h2) with their parent h1
-        const commandHeadings = sortedToc.filter((entry) => entry.level === 2);
-        // Group h2 by parent h1 for easier traversal
-        const h1ToH2Map = new Map();
-        for (const h1 of mainHeadings) {
-            h1ToH2Map.set(h1.hash, []);
+        // Build the heading hierarchy based on level and parentHash
+        const headingsByHash = new Map();
+        const childrenByParent = new Map();
+        const validHeadingsByLevel = new Map();
+        // Initialize valid headings collections for each level
+        for (let level = 1; level <= 3; level++) {
+            validHeadingsByLevel.set(level, new Set());
         }
-        for (const h2 of commandHeadings) {
-            if (h2.parentHash) {
-                const h2List = h1ToH2Map.get(h2.parentHash) || [];
-                h2List.push(h2);
-                h1ToH2Map.set(h2.parentHash, h2List);
+        // First pass: Collect all headings by hash
+        for (const entry of sortedToc) {
+            headingsByHash.set(entry.hash, entry);
+            // Store valid headings by level
+            if (entry.level && entry.level >= 1 && entry.level <= 3) {
+                validHeadingsByLevel.get(entry.level).add(entry.hash);
             }
         }
-        // 3. Find all subheadings (h3) with their parent h2
-        const subheadings = sortedToc.filter((entry) => entry.level === 3);
-        // Group h3 by parent h2 for easier traversal
-        const h2ToH3Map = new Map();
-        for (const h2 of commandHeadings) {
-            h2ToH3Map.set(h2.hash, []);
-        }
-        for (const h3 of subheadings) {
-            if (h3.parentHash) {
-                const h3List = h2ToH3Map.get(h3.parentHash) || [];
-                h3List.push(h3);
-                h2ToH3Map.set(h3.parentHash, h3List);
+        // Second pass: Validate parent-child relationships
+        const invalidHashesCollectionByReason = new Map();
+        const addInvalidHash = (hash, reason) => {
+            if (!invalidHashesCollectionByReason.has(reason)) {
+                invalidHashesCollectionByReason.set(reason, new Set());
             }
-        }
-        // Find all unique h3 titles that appear anywhere
-        const allH3Titles = new Set();
-        for (const h3 of subheadings) {
-            allH3Titles.add(h3.title);
-        }
-        // Common expected subheadings for commands
-        const commonSubheadings = [
-            "요약",
-            "개요",
-            "설명",
-            "옵션",
-            "문법",
-            "주요 명령어",
-            "주요 속성 설명",
-            "설치",
-            "기본 명령",
-        ];
-        // Add common subheadings to the set
-        for (const title of commonSubheadings) {
-            allH3Titles.add(title);
-        }
-        reporter.info(`Found ${allH3Titles.size} unique h3 titles across sections`);
-        // For each command, ensure all common subheadings exist
-        const finalToc = [...sortedToc];
-        let addedEntries = 0;
-        // Create a map of known title combinations to avoid duplicates
-        const knownCombinations = new Set();
-        // Add all existing combinations to the known set
-        for (const entry of subheadings) {
+            invalidHashesCollectionByReason.get(reason).add(hash);
+        };
+        // Build parent-child relationship map
+        for (const entry of sortedToc) {
             if (entry.parentHash) {
-                const parentCommand = commandHeadings.find((h2) => h2.hash === entry.parentHash);
-                if (parentCommand) {
-                    const combo = `${parentCommand.title}:${entry.title}`;
-                    knownCombinations.add(combo);
+                // Check if parent exists
+                const parentExists = headingsByHash.has(entry.parentHash);
+                if (parentExists) {
+                    // Add this entry as a child of its parent
+                    if (!childrenByParent.has(entry.parentHash)) {
+                        childrenByParent.set(entry.parentHash, new Set());
+                    }
+                    childrenByParent.get(entry.parentHash).add(entry.hash);
+                }
+                else {
+                    // Invalid parent reference
+                    addInvalidHash(entry.hash, "orphaned");
                 }
+                // Validate level relationships
+                const parent = headingsByHash.get(entry.parentHash);
+                if (parent && entry.level && parent.level) {
+                    if (entry.level <= parent.level) {
+                        // Invalid level hierarchy (e.g. H2 with H2 or H3 parent)
+                        addInvalidHash(entry.hash, "invalid_level");
+                    }
+                    if (entry.level > parent.level + 1) {
+                        // Skip levels (e.g. H1 -> H3 directly)
+                        // This is actually valid in the new implementation, but we want to note it
+                        reporter.info(`Found H${entry.level} heading "${entry.title}" directly under H${parent.level}`);
+                    }
+                }
+            }
+            else if (entry.level && entry.level > 1) {
+                // No parent hash but not a top-level heading
+                addInvalidHash(entry.hash, "missing_parent");
             }
         }
-        // Check which commands are missing which subheadings
-        for (const h2 of commandHeadings) {
-            const h3Entries = h2ToH3Map.get(h2.hash) || [];
-            const existingTitles = new Set(h3Entries.map((entry) => entry.title));
-            // For each expected subheading, check if it exists
-            for (const title of commonSubheadings) {
-                const combo = `${h2.title}:${title}`;
-                // Skip if we already have this combination
-                if (knownCombinations.has(combo) || existingTitles.has(title)) {
-                    continue;
+        // Identify common command names for special handling
+        const commonCommandPattern = /^(cp|mv|rm|find|locate|grep|curl|wget|ls|chmod|chown|ps|sed|awk|cat|service|file|stat)$/i;
+        // Third pass: Identify structurally invalid entries based on context
+        const invalidEntries = new Set();
+        // Process invalid entries from previous validations
+        for (const [reason, hashes] of invalidHashesCollectionByReason.entries()) {
+            if (reason === "orphaned" ||
+                reason === "invalid_level" ||
+                reason === "missing_parent") {
+                for (const hash of hashes) {
+                    invalidEntries.add(hash);
                 }
-                // We don't have this subheading for this command - but don't add synthetic entries
-                // in this implementation as we want to show only what's actually in the document
             }
         }
-        // If we added entries, re-sort the TOC
-        if (addedEntries > 0) {
-            reporter.info(`Added ${addedEntries} missing subheadings to TOC`);
-            finalToc.sort((a, b) => {
-                if ((a.level || 0) !== (b.level || 0)) {
-                    return (a.level || 0) - (b.level || 0);
+        // Find server/service sections
+        const serverSections = sortedToc.filter((entry) => entry.level === 1 &&
+            (entry.title.includes("서버") ||
+                entry.title.includes("Server") ||
+                entry.title.includes("프록시")));
+        // Process special handling for server sections
+        for (const serverSection of serverSections) {
+            // Get direct children of this server section
+            const directChildren = childrenByParent.get(serverSection.hash) || new Set();
+            // Check each child for common command pattern matching
+            for (const childHash of directChildren) {
+                const child = headingsByHash.get(childHash);
+                if (child && commonCommandPattern.test(child.title)) {
+                    // Check if this child has valid descendants or content
+                    const childHasChildren = childrenByParent.has(childHash) &&
+                        childrenByParent.get(childHash).size > 0;
+                    // Special check for service section headings - common commands shouldn't be here
+                    // if they don't have meaningful content
+                    if (!childHasChildren) {
+                        invalidEntries.add(childHash);
+                        // Also, mark children as invalid if there are any
+                        if (childrenByParent.has(childHash)) {
+                            for (const grandChildHash of childrenByParent.get(childHash)) {
+                                invalidEntries.add(grandChildHash);
+                            }
+                        }
+                    }
                 }
-                return 0;
-            });
+            }
         }
-        // Always make sure all h3 entries have context titles that include their parent command
-        for (const entry of finalToc) {
-            if (entry.level === 3 && entry.parentHash) {
-                const parentCommand = commandHeadings.find((h2) => h2.hash === entry.parentHash);
-                if (parentCommand) {
-                    entry.contextTitle = `${entry.title} (${parentCommand.title})`;
+        // Ensure the correct context titles reflect the parent relationship
+        for (const entry of sortedToc) {
+            if (entry.level === 2 && entry.parentHash) {
+                const parent = headingsByHash.get(entry.parentHash);
+                if (parent) {
+                    entry.contextTitle = `${entry.title} (${parent.title})`;
                 }
             }
+            else if (entry.level === 3 && entry.parentHash) {
+                // For H3, prefer its direct parent, whether H2 or H1
+                const parent = headingsByHash.get(entry.parentHash);
+                if (parent) {
+                    entry.contextTitle = `${entry.title} (${parent.title})`;
+                }
+            }
+        }
+        // Create a filtered TOC without invalid entries
+        const validToc = sortedToc.filter((entry) => !invalidEntries.has(entry.hash));
+        if (invalidEntries.size > 0) {
+            reporter.info(`Removed ${invalidEntries.size} invalid TOC entries`);
         }
-        return finalToc;
+        return validToc;
     }
     catch (error) {
         reporter.error(`Error formatting table of contents: ${error}`);

package/dist/util/tableOfContent.js

@@ -4,104 +4,84 @@ exports.processTableOfContents = exports.resetTocContext = void 0;
 const crypto_1 = require("crypto");
 // Hash 생성 시 사용할 캐시
 const hashCache = new Map();
-// 헤딩 레벨 트래킹을 위한 변수들
-let lastH1Hash = "";
-let lastH2Hash = "";
-let lastH1Title = "";
-let lastH2Title = "";
-let currentCommandSection = ""; // 현재 명령어 섹션 추적
+// 계층별 컨텍스트 저장
+const headingStack = [];
+let lastHeadingByLevel = [null, null, null, null]; // 인덱스 1부터 3까지 사용
 const resetTocContext = () => {
-    lastH1Hash = "";
-    lastH2Hash = "";
-    lastH1Title = "";
-    lastH2Title = "";
-    currentCommandSection = "";
+    headingStack.length = 0;
+    lastHeadingByLevel = [null, null, null, null];
+    hashCache.clear();
 };
 exports.resetTocContext = resetTocContext;
+// 필요한 수준의 상위 헤딩 찾기
+const findParentHeading = (currentLevel) => {
+    // 자신보다 낮은 레벨의 가장 가까운 헤딩 찾기 (1 < 2 < 3)
+    for (let level = currentLevel - 1; level > 0; level--) {
+        if (lastHeadingByLevel[level]) {
+            return lastHeadingByLevel[level];
+        }
+    }
+    return null;
+};
+const generateHash = (text) => {
+    return `link-${text
+        .replace(/[^a-zA-Z0-9가-힣\s-_]/g, "")
+        .trim()
+        .replace(/\s+/g, "-")
+        .toLowerCase()}-${(0, crypto_1.randomUUID)().substring(0, 4)}`;
+};
 const processTableOfContents = async (block, tableOfContents) => {
     if (["heading_1", "heading_2", "heading_3"].includes(block.type) &&
         block[block.type]?.rich_text?.length > 0) {
         const plainText = block[block.type]?.rich_text?.[0]?.plain_text || "";
-        // 부모 컨텍스트 추가
-        let contextualId = plainText;
-        let parentHash = "";
-        let level = 0;
-        // 상위 헤딩에 따라 컨텍스트 저장
-        if (block.type === "heading_1") {
-            lastH1Title = plainText;
-            lastH2Title = "";
-            lastH2Hash = ""; // H1을 만나면 H2 해시도 초기화
-            currentCommandSection = ""; // 새 섹션 시작
-            contextualId = `h1-${plainText}`;
-            level = 1;
-            // heading_1은 최상위 레벨이므로 부모가 없음
-        }
-        else if (block.type === "heading_2") {
-            // H2는 반드시 H1 아래에 속함
-            lastH2Title = plainText;
-            currentCommandSection = plainText; // 현재 명령어 설정 (예: useradd, usermod 등)
-            contextualId = `h2-${lastH1Title}-${plainText}`;
-            parentHash = lastH1Hash; // heading_2의 부모는 가장 최근의 heading_1
-            level = 2;
-        }
-        else if (block.type === "heading_3") {
-            // H3 처리를 개선
-            const parentSectionInfo = lastH2Hash
-                ? currentCommandSection
-                : lastH1Title;
-            const fullContextId = `h3-${lastH1Title}-${parentSectionInfo}-${plainText}`;
-            contextualId = fullContextId;
-            // 현재 H2가 없다면 바로 H1을 부모로 설정
-            parentHash = lastH2Hash || lastH1Hash;
-            // H2가 없는 경우 현재 H1 제목을 컨텍스트로 사용
-            if (!lastH2Hash) {
-                currentCommandSection = lastH1Title;
-            }
-            level = 3;
-        }
-        // 이미 처리된 플레인텍스트인지 확인
+        // 헤딩 레벨 추출 (heading_1 -> 1, heading_2 -> 2, heading_3 -> 3)
+        const level = parseInt(block.type.split("_")[1]);
+        // 현재 헤딩의 컨텍스트 ID 생성
+        const contextualId = `h${level}-${plainText}`;
+        // 해시 생성 또는 캐시에서 가져오기
         let hash;
         if (hashCache.has(contextualId)) {
             hash = hashCache.get(contextualId);
         }
         else {
-            hash = `link-${plainText
-                .replace(/[^a-zA-Z0-9가-힣\s-_]/g, "")
-                .trim()
-                .replace(/\s+/g, "-")
-                .toLowerCase()}-${(0, crypto_1.randomUUID)().substring(0, 4)}`;
+            hash = generateHash(plainText);
             hashCache.set(contextualId, hash);
         }
-        // 현재 해시 저장
-        if (block.type === "heading_1") {
-            lastH1Hash = hash;
-        }
-        else if (block.type === "heading_2") {
-            lastH2Hash = hash;
-        }
         block.hash = hash;
-        // 항상 복사본을 사용하여 중복을 방지
-        const displayTitle = plainText;
-        let contextTitle = displayTitle;
-        // 서브헤딩에 컨텍스트 추가 (H3)
-        if (level === 3) {
-            // H2가 없으면 H1을 컨텍스트로 사용
-            const contextSectionName = lastH2Hash
-                ? currentCommandSection
-                : lastH1Title;
-            contextTitle = `${plainText} (${contextSectionName})`;
+        // 계층 구조 관리 - 현재 레벨보다 높은 모든 하위 헤딩 컨텍스트 삭제
+        // 예: H1이 나오면 H2, H3 컨텍스트 초기화
+        for (let i = level + 1; i < lastHeadingByLevel.length; i++) {
+            lastHeadingByLevel[i] = null;
+        }
+        // 부모 헤딩 찾기
+        const parentHeading = findParentHeading(level);
+        const parentHash = parentHeading ? parentHeading.hash : "";
+        // 부모 헤딩 스택에 자식으로 등록
+        if (parentHeading) {
+            parentHeading.children.push(hash);
         }
-        // H2 항목도 컨텍스트 추가
-        else if (level === 2) {
-            contextTitle = `${plainText} (${lastH1Title})`;
+        // 컨텍스트 제목 생성
+        let contextTitle = plainText;
+        // 부모 컨텍스트 추가
+        if (level > 1 && parentHeading) {
+            contextTitle = `${plainText} (${parentHeading.title})`;
         }
+        // 자신을 현재 레벨의 마지막 헤딩으로 등록
+        const currentHeading = {
+            hash,
+            title: plainText,
+            level,
+            children: [],
+        };
+        lastHeadingByLevel[level] = currentHeading;
         // 중복 체크 - 동일한 hash가 이미 존재하는지 확인
         const existingTocIndex = tableOfContents.findIndex((toc) => toc.hash === hash);
         if (existingTocIndex === -1) {
+            // TOC 항목 추가
             tableOfContents.push({
                 type: block.type,
                 hash,
-                title: displayTitle,
+                title: plainText,
                 contextTitle,
                 parentHash,
                 level,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gatsby-source-notion-churnotion",
   "description": "Gatsby plugin that can connect with One Notion Database RECURSIVELY using official API",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "skipLibCheck": true,
   "license": "0BSD",
   "main": "./dist/gatsby-node.js",