gatsby-source-notion-churnotion 1.2.5 → 1.2.7

package/dist/util/resolvers.js

@@ -26,108 +26,100 @@ 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, []);
-        }
-        for (const h2 of commandHeadings) {
-            if (h2.parentHash) {
-                const h2List = h1ToH2Map.get(h2.parentHash) || [];
-                h2List.push(h2);
-                h1ToH2Map.set(h2.parentHash, h2List);
+        // H1 섹션별 명령어 매핑 & 실제 자식 항목 분석
+        const h1Sections = new Map(); // H1 해시 -> H1 항목
+        const h1Children = new Map(); // H1 해시 -> H2 자식 해시 세트
+        const h2Children = new Map(); // H2 해시 -> H3 자식 해시 세트
+        // 1단계: 모든 H1 항목 수집
+        for (const entry of sortedToc) {
+            if (entry.level === 1) {
+                h1Sections.set(entry.hash, entry);
+                h1Children.set(entry.hash, new Set());
             }
         }
-        // 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);
+        // 2단계: 정당한 H2 항목 식별 (H1의 직접 자식)
+        for (const entry of sortedToc) {
+            if (entry.level === 2 &&
+                entry.parentHash &&
+                h1Sections.has(entry.parentHash)) {
+                // H1의 자식으로 추가
+                h1Children.get(entry.parentHash).add(entry.hash);
+                h2Children.set(entry.hash, 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) {
-            if (entry.parentHash) {
-                const parentCommand = commandHeadings.find((h2) => h2.hash === entry.parentHash);
-                if (parentCommand) {
-                    const combo = `${parentCommand.title}:${entry.title}`;
-                    knownCombinations.add(combo);
+        // 3단계: 정당한 H3 항목 식별 (H2의 직접 자식)
+        for (const entry of sortedToc) {
+            if (entry.level === 3 && entry.parentHash) {
+                // 부모가 H2인 경우
+                if (h2Children.has(entry.parentHash)) {
+                    h2Children.get(entry.parentHash).add(entry.hash);
                 }
             }
         }
-        // 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;
+        // 4단계: 각 H1 섹션 내에서 일반적인 명령어 이름이 실제 내용을 가지는지 확인
+        const commandSections = new Map(); // H1 해시 -> (명령어 이름 -> 유효성)
+        const duplicateCommandNames = new Set();
+        // 모든 섹션에서 명령어 이름 수집
+        for (const entry of sortedToc) {
+            if (entry.level === 2) {
+                // 일반적인 명령어 이름인지 확인
+                const isCommonCommand = /^(cp|mv|rm|find|grep|curl|wget|ls|chmod|chown|ps|sed|awk|cat|service|file|locate|stat)$/.test(entry.title.toLowerCase());
+                if (isCommonCommand) {
+                    duplicateCommandNames.add(entry.title.toLowerCase());
+                    // 이 명령어가 실제 H3 자식을 가지는지 확인
+                    const hasChildren = !!(entry.parentHash &&
+                        h2Children.has(entry.hash) &&
+                        h2Children.get(entry.hash).size > 0);
+                    // 섹션별 명령어 유효성 추적
+                    if (entry.parentHash) {
+                        if (!commandSections.has(entry.parentHash)) {
+                            commandSections.set(entry.parentHash, new Map());
+                        }
+                        commandSections
+                            .get(entry.parentHash)
+                            .set(entry.title.toLowerCase(), hasChildren);
+                    }
                 }
-                // 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);
-                }
-                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})`;
+        // 5단계: 유효하지 않은 명령어 항목 필터링
+        const invalidEntries = new Set();
+        // Squid 프록시 서버와 같은 특정 섹션의 특별 처리
+        const squidSectionEntry = sortedToc.find((entry) => entry.level === 1 && entry.title.includes("Squid 프록시 서버"));
+        if (squidSectionEntry) {
+            const squidSectionHash = squidSectionEntry.hash;
+            const squidCommandStatus = commandSections.get(squidSectionHash);
+            // Squid 섹션의 모든 H2 항목 검토
+            for (const entry of sortedToc) {
+                if (entry.level === 2 && entry.parentHash === squidSectionHash) {
+                    // 일반적인 명령어 이름이면서 실제 내용(H3 자식)이 없는 항목은 제거 대상
+                    const isCommonCommand = /^(cp|mv|rm|find|grep|curl|wget|ls|chmod|chown|ps|sed|awk|cat|service|file|locate|stat)$/.test(entry.title.toLowerCase());
+                    // Squid 섹션 특성에 맞지 않는 일반 명령어 식별
+                    if (isCommonCommand) {
+                        // 이 명령어가 Squid 섹션에서 정당한 내용을 가지는지 확인
+                        const hasValidChildren = !!(entry.hash &&
+                            h2Children.has(entry.hash) &&
+                            h2Children.get(entry.hash).size > 0);
+                        // 내용 없는 명령어는 제거
+                        if (!hasValidChildren) {
+                            invalidEntries.add(entry.hash);
+                            // 이 명령어의 모든 자식도 제거 (혹시 있을 경우)
+                            for (const childEntry of sortedToc) {
+                                if (childEntry.parentHash === entry.hash) {
+                                    invalidEntries.add(childEntry.hash);
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
-        return finalToc;
+        // 유효하지 않은 항목 제외한 결과 생성
+        const validToc = sortedToc.filter((entry) => !invalidEntries.has(entry.hash));
+        if (invalidEntries.size > 0) {
+            reporter.info(`Removed ${invalidEntries.size} invalid TOC entries from special sections`);
+        }
+        return validToc;
     }
     catch (error) {
         reporter.error(`Error formatting table of contents: ${error}`);

package/dist/util/tableOfContent.js

@@ -30,12 +30,14 @@ const processTableOfContents = async (block, tableOfContents) => {
         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}`;
@@ -43,10 +45,18 @@ const processTableOfContents = async (block, tableOfContents) => {
             level = 2;
         }
         else if (block.type === "heading_3") {
-            // 서브섹션 제목에 명령어 컨텍스트 추가 (예: 요약 -> useradd 요약)
-            const fullContextId = `h3-${lastH1Title}-${currentCommandSection}-${plainText}`;
+            // H3 처리를 개선
+            const parentSectionInfo = lastH2Hash
+                ? currentCommandSection
+                : lastH1Title;
+            const fullContextId = `h3-${lastH1Title}-${parentSectionInfo}-${plainText}`;
             contextualId = fullContextId;
-            parentHash = lastH2Hash || lastH1Hash; // heading_3의 부모는 가장 최근의 heading_2, 없으면 heading_1
+            // 현재 H2가 없다면 바로 H1을 부모로 설정
+            parentHash = lastH2Hash || lastH1Hash;
+            // H2가 없는 경우 현재 H1 제목을 컨텍스트로 사용
+            if (!lastH2Hash) {
+                currentCommandSection = lastH1Title;
+            }
             level = 3;
         }
         // 이미 처리된 플레인텍스트인지 확인
@@ -73,9 +83,17 @@ const processTableOfContents = async (block, tableOfContents) => {
         // 항상 복사본을 사용하여 중복을 방지
         const displayTitle = plainText;
         let contextTitle = displayTitle;
-        // 서브헤딩에 컨텍스트 추가
-        if (level === 3 && currentCommandSection) {
-            contextTitle = `${plainText} (${currentCommandSection})`;
+        // 서브헤딩에 컨텍스트 추가 (H3)
+        if (level === 3) {
+            // H2가 없으면 H1을 컨텍스트로 사용
+            const contextSectionName = lastH2Hash
+                ? currentCommandSection
+                : lastH1Title;
+            contextTitle = `${plainText} (${contextSectionName})`;
+        }
+        // H2 항목도 컨텍스트 추가
+        else if (level === 2) {
+            contextTitle = `${plainText} (${lastH1Title})`;
         }
         // 중복 체크 - 동일한 hash가 이미 존재하는지 확인
         const existingTocIndex = tableOfContents.findIndex((toc) => toc.hash === hash);

package/dist/util/tocHelper.d.ts

@@ -22,6 +22,10 @@ export declare const optimizeTocArray: (tocEntries: TocEntry[], reporter: Report
     enhanceDuplicates?: boolean;
     buildHierarchy?: boolean;
 }) => TocEntry[];
+/**
+ * TOC 구조의 유효성을 검사하고 문제가 있는 항목을 필터링
+ */
+export declare const validateTocStructure: (tocEntries: TocEntry[], reporter: Reporter) => TocEntry[];
 /**
  * Enhances TOC entries with contextual titles to disambiguate duplicate titles
  */

package/dist/util/tocHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enrichDuplicateTitles = exports.optimizeTocArray = void 0;
+exports.enrichDuplicateTitles = exports.validateTocStructure = exports.optimizeTocArray = void 0;
 /**
  * Utility function to efficiently handle large table of contents arrays
  * by removing duplicates and optionally limiting size while preserving hierarchy
@@ -33,20 +33,95 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
         }
         return entry;
     });
+    // 구조적 유효성 검증 및 정리
+    const validatedToc = (0, exports.validateTocStructure)(enrichedTocEntries, reporter);
     // Remove duplicates if requested
-    let processedToc = enrichedTocEntries;
+    let processedToc = validatedToc;
     if (removeDuplicates) {
         const startTime = Date.now();
+        // 중복 해시 및 타이틀 검사를 위한 맵
         const uniqueMap = new Map();
-        // Use the hash to ensure uniqueness, but preserve context
-        for (const entry of enrichedTocEntries) {
-            uniqueMap.set(entry.hash, entry);
+        // 섹션별 유효한 하위 항목 분류
+        const h1Entries = new Map(); // 최상위 항목
+        const childEntries = new Map(); // 상위 해시 -> 하위 해시 세트
+        // 1. 먼저 모든 H1 항목을 수집하고 맵에 저장
+        for (const entry of validatedToc) {
+            if (entry.level === 1) {
+                h1Entries.set(entry.hash, entry);
+                childEntries.set(entry.hash, new Set());
+            }
+        }
+        // 2. 각 항목을 처리하여 해시 기반으로 적절한 부모-자식 관계 검증
+        for (const entry of validatedToc) {
+            // H1은 이미 처리됨
+            if (entry.level === 1) {
+                uniqueMap.set(entry.hash, entry);
+                continue;
+            }
+            // H2, H3 항목 처리
+            if (entry.parentHash) {
+                // 부모 해시가 있는 경우 부모가 실제로 존재하는지 확인
+                const parentExists = uniqueMap.has(entry.parentHash) || h1Entries.has(entry.parentHash);
+                if (parentExists) {
+                    // 부모에 이 항목을 자식으로 추가
+                    if (childEntries.has(entry.parentHash)) {
+                        childEntries.get(entry.parentHash).add(entry.hash);
+                    }
+                    else {
+                        childEntries.set(entry.parentHash, new Set([entry.hash]));
+                    }
+                    // 항목을 유효한 것으로 추가
+                    uniqueMap.set(entry.hash, entry);
+                }
+                else {
+                    // 부모가 존재하지 않는 고아 항목
+                    reporter.warn(`Skipping orphaned TOC entry: ${entry.title} (parent hash ${entry.parentHash} not found)`);
+                }
+            }
+            else if (entry.level === 2) {
+                // H2 항목이지만 부모 해시가 없는 경우 (비정상)
+                reporter.warn(`Skipping H2 entry without parent: ${entry.title}`);
+            }
+            else {
+                // 부모 해시가 없지만 유효할 수 있는 항목
+                uniqueMap.set(entry.hash, entry);
+            }
         }
+        // 내부 일관성 검사: 동일한 제목의 항목이 여러 섹션에 있는 경우
+        const titleToSections = new Map();
+        for (const entry of uniqueMap.values()) {
+            if (entry.level === 2) {
+                const title = entry.title.toLowerCase();
+                if (!titleToSections.has(title)) {
+                    titleToSections.set(title, new Set());
+                }
+                // 이 제목이 속한 부모 H1 추적
+                if (entry.parentHash) {
+                    titleToSections.get(title).add(entry.parentHash);
+                }
+            }
+        }
+        // 여러 섹션에 동일한 제목의 H2가 있는지 확인하고, 영향받는 H2의 contextTitle을 더 강화
+        for (const [title, sections] of titleToSections.entries()) {
+            if (sections.size > 1) {
+                reporter.info(`Title "${title}" appears across ${sections.size} different sections. Enhancing context.`);
+                // 해당 제목의 모든 항목에 대해 상위 항목의 제목을 컨텍스트에 추가
+                for (const entry of uniqueMap.values()) {
+                    if (entry.title.toLowerCase() === title && entry.parentHash) {
+                        const parentEntry = h1Entries.get(entry.parentHash);
+                        if (parentEntry) {
+                            entry.contextTitle = `${entry.title} (${parentEntry.title})`;
+                        }
+                    }
+                }
+            }
+        }
+        // 최종 결과를 배열로 변환
         processedToc = Array.from(uniqueMap.values());
-        const removedCount = enrichedTocEntries.length - processedToc.length;
+        const removedCount = validatedToc.length - processedToc.length;
         const processTime = Date.now() - startTime;
         if (removedCount > 0) {
-            reporter.info(`Removed ${removedCount} duplicate TOC entries in ${processTime}ms.`);
+            reporter.info(`Removed ${removedCount} duplicate/invalid TOC entries in ${processTime}ms.`);
         }
     }
     // Add context to duplicate title entries for better display
@@ -76,6 +151,107 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
     return processedToc;
 };
 exports.optimizeTocArray = optimizeTocArray;
+/**
+ * TOC 구조의 유효성을 검사하고 문제가 있는 항목을 필터링
+ */
+const validateTocStructure = (tocEntries, reporter) => {
+    if (!tocEntries || tocEntries.length === 0) {
+        return [];
+    }
+    // 1. 섹션별 매핑 구성
+    const h1Map = new Map();
+    const h1Children = new Map();
+    // 2. 모든 H1 항목 수집
+    for (const entry of tocEntries) {
+        if (entry.level === 1) {
+            h1Map.set(entry.hash, entry);
+            h1Children.set(entry.hash, new Set());
+        }
+    }
+    // H1이 없으면 원본 반환
+    if (h1Map.size === 0) {
+        return tocEntries;
+    }
+    // 3. 각 항목을 올바른 부모에 연결
+    for (const entry of tocEntries) {
+        if (entry.level !== 1 && entry.parentHash) {
+            // 부모가 H1인 경우
+            if (h1Map.has(entry.parentHash)) {
+                h1Children.get(entry.parentHash).add(entry.hash);
+            }
+        }
+    }
+    // 4. 각 H1 섹션 내에서 중복된 H2/H3 타이틀 발견 (같은 섹션에 동일 타이틀 중복)
+    const suspiciousEntries = new Set();
+    const sectionTitles = new Map();
+    for (const [h1Hash, childHashes] of h1Children.entries()) {
+        const titleCounts = new Map();
+        sectionTitles.set(h1Hash, titleCounts);
+        // 이 H1에 속한 모든 자식 항목 검사
+        for (const entry of tocEntries) {
+            if ((entry.level === 2 || entry.level === 3) &&
+                entry.parentHash === h1Hash) {
+                const title = entry.title.toLowerCase();
+                const count = (titleCounts.get(title) || 0) + 1;
+                titleCounts.set(title, count);
+                // 이 섹션에 이 제목이 이미 있으면 중복으로 표시
+                if (count > 1) {
+                    suspiciousEntries.add(entry.hash);
+                }
+            }
+        }
+    }
+    // 5. 다른 섹션에 속할 것으로 보이는 항목 식별 (예: 14. Squid 프록시 서버의 잘못된 자식)
+    const titleToSections = new Map();
+    for (const entry of tocEntries) {
+        if (entry.level === 2) {
+            const title = entry.title.toLowerCase();
+            if (!titleToSections.has(title)) {
+                titleToSections.set(title, new Set());
+            }
+            // 이 제목이 어떤 H1 섹션에 속하는지 기록
+            if (entry.parentHash) {
+                titleToSections.get(title).add(entry.parentHash);
+            }
+        }
+    }
+    // 여러 섹션에 동일한 제목의 항목이 있는지 검사
+    for (const [title, sections] of titleToSections.entries()) {
+        if (sections.size > 1) {
+            reporter.info(`Title "${title}" appears across ${sections.size} different sections.`);
+            // 일반적인 명령어 이름인지 확인 (cp, mv, rm 등)
+            const isCommonCommand = /^(cp|mv|rm|find|grep|curl|wget|ls|chmod|chown|ps|sed|awk|cat|service|file|locate|stat)$/.test(title);
+            if (isCommonCommand) {
+                reporter.info(`"${title}" is a common command name that appears in multiple sections.`);
+                // 각 섹션의 항목 분석
+                for (const entry of tocEntries) {
+                    if (entry.title.toLowerCase() === title && entry.level === 2) {
+                        // 이 H2 항목이 이 섹션의 내용과 일치하는지 확인할 방법이 필요
+                        // 예: 이 H2와 연결된 H3 항목이 정당한지 검사
+                        let hasValidChildren = false;
+                        for (const child of tocEntries) {
+                            if (child.level === 3 && child.parentHash === entry.hash) {
+                                hasValidChildren = true;
+                                break;
+                            }
+                        }
+                        // 자식이 없는 중복된 명령어는 다른 섹션에서 복사된 것일 가능성이 높음
+                        if (!hasValidChildren && sections.size > 1) {
+                            suspiciousEntries.add(entry.hash);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 6. 의심스러운 항목 수 보고
+    if (suspiciousEntries.size > 0) {
+        reporter.info(`Found ${suspiciousEntries.size} suspicious TOC entries that might be duplicates`);
+    }
+    // 7. 의심스러운 항목 제거된 결과 반환
+    return tocEntries.filter((entry) => !suspiciousEntries.has(entry.hash));
+};
+exports.validateTocStructure = validateTocStructure;
 /**
  * Enhances TOC entries with contextual titles to disambiguate duplicate titles
  */

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.5",
+  "version": "1.2.7",
   "skipLibCheck": true,
   "license": "0BSD",
   "main": "./dist/gatsby-node.js",