gatsby-source-notion-churnotion 1.2.8 → 1.2.9

package/dist/util/resolvers.js

@@ -106,17 +106,31 @@ const formatTableOfContents = (tableOfContents, reporter) => {
                 entry.title.includes("프록시")));
         // Process special handling for server sections
         for (const serverSection of serverSections) {
+            // 스퀴드 프록시 서버 섹션인지 특별히 확인
+            const isSquidProxySection = serverSection.title.includes("Squid") ||
+                serverSection.title.includes("프록시") ||
+                serverSection.title.includes("Proxy");
             // 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
+                    // 스퀴드 프록시 섹션의 명령어는 무조건 제거 (컨텐츠 유무와 상관없이)
+                    if (isSquidProxySection) {
+                        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);
+                            }
+                        }
+                        continue;
+                    }
+                    // 다른 서버 섹션은 기존 로직대로 처리
                     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
+                    // Special check for service section headings
                     if (!childHasChildren) {
                         invalidEntries.add(childHash);
                         // Also, mark children as invalid if there are any
@@ -145,6 +159,37 @@ const formatTableOfContents = (tableOfContents, reporter) => {
                 }
             }
         }
+        // 최종 필터링 - 강제 제거 대상
+        const forceRemoveMap = new Map(); // 부모 해시 -> 제거할 자식 해시 세트
+        // 스퀴드 프록시 서버 섹션 찾기
+        const squidSection = sortedToc.find((entry) => entry.level === 1 &&
+            (entry.title.includes("Squid") ||
+                entry.title.includes("프록시") ||
+                entry.title.includes("Proxy")));
+        if (squidSection) {
+            // 스퀴드 섹션 내 명령어 찾기
+            const squidChildEntries = sortedToc.filter((entry) => entry.level === 2 && entry.parentHash === squidSection.hash);
+            // 일반 명령어 패턴
+            const finalCommandPattern = /^(cp|mv|rm|find|locate|grep|curl|wget|ls|chmod|chown|ps|sed|awk|cat|service|file|stat)$/i;
+            // 스퀴드 섹션 내 명령어 중 일반 명령어인 경우
+            for (const child of squidChildEntries) {
+                if (finalCommandPattern.test(child.title)) {
+                    // 제거 대상 목록에 추가
+                    if (!forceRemoveMap.has(squidSection.hash)) {
+                        forceRemoveMap.set(squidSection.hash, new Set());
+                    }
+                    forceRemoveMap.get(squidSection.hash).add(child.hash);
+                    // 해당 명령어의 자식들도 제거 대상에 추가
+                    const childChildren = sortedToc.filter((entry) => entry.parentHash === child.hash);
+                    for (const grandChild of childChildren) {
+                        invalidEntries.add(grandChild.hash);
+                    }
+                    // 명령어 자체도 제거 대상에 추가
+                    invalidEntries.add(child.hash);
+                }
+            }
+            reporter.info(`Forcibly removed ${invalidEntries.size} entries from Squid Proxy section`);
+        }
         // Create a filtered TOC without invalid entries
         const validToc = sortedToc.filter((entry) => !invalidEntries.has(entry.hash));
         if (invalidEntries.size > 0) {

package/dist/util/tableOfContent.js

@@ -2,27 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processTableOfContents = exports.resetTocContext = void 0;
 const crypto_1 = require("crypto");
-// Hash 생성 시 사용할 캐시
+// Hash cache for generation
 const hashCache = new Map();
-// 계층별 컨텍스트 저장
-const headingStack = [];
-let lastHeadingByLevel = [null, null, null, null]; // 인덱스 1부터 3까지 사용
-const resetTocContext = () => {
-    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;
-};
+// Track current context by level
+let currentH1 = null;
+let currentH2 = null;
+let currentH3 = null;
+// Generate a hash for a heading
 const generateHash = (text) => {
     return `link-${text
         .replace(/[^a-zA-Z0-9가-힣\s-_]/g, "")
@@ -30,15 +16,22 @@ const generateHash = (text) => {
         .replace(/\s+/g, "-")
         .toLowerCase()}-${(0, crypto_1.randomUUID)().substring(0, 4)}`;
 };
+// Reset context between pages/documents
+const resetTocContext = () => {
+    currentH1 = null;
+    currentH2 = null;
+    currentH3 = null;
+    hashCache.clear();
+};
+exports.resetTocContext = resetTocContext;
 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 || "";
-        // 헤딩 레벨 추출 (heading_1 -> 1, heading_2 -> 2, heading_3 -> 3)
+        // Extract heading level (1, 2, or 3)
         const level = parseInt(block.type.split("_")[1]);
-        // 현재 헤딩의 컨텍스트 ID 생성
+        // Generate or retrieve hash from cache
         const contextualId = `h${level}-${plainText}`;
-        // 해시 생성 또는 캐시에서 가져오기
         let hash;
         if (hashCache.has(contextualId)) {
             hash = hashCache.get(contextualId);
@@ -47,37 +40,53 @@ const processTableOfContents = async (block, tableOfContents) => {
             hash = generateHash(plainText);
             hashCache.set(contextualId, hash);
         }
+        // Set hash on block for reference
         block.hash = hash;
-        // 계층 구조 관리 - 현재 레벨보다 높은 모든 하위 헤딩 컨텍스트 삭제
-        // 예: 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);
-        }
-        // 컨텍스트 제목 생성
-        let contextTitle = plainText;
-        // 부모 컨텍스트 추가
-        if (level > 1 && parentHeading) {
-            contextTitle = `${plainText} (${parentHeading.title})`;
-        }
-        // 자신을 현재 레벨의 마지막 헤딩으로 등록
-        const currentHeading = {
+        // Create new heading context
+        const newHeading = {
             hash,
             title: plainText,
             level,
             children: [],
         };
-        lastHeadingByLevel[level] = currentHeading;
-        // 중복 체크 - 동일한 hash가 이미 존재하는지 확인
+        // Manage hierarchy based on heading level
+        let parentHash = "";
+        let contextTitle = plainText;
+        if (level === 1) {
+            // New H1 starts a completely new context
+            currentH1 = newHeading;
+            currentH2 = null;
+            currentH3 = null;
+            parentHash = "";
+        }
+        else if (level === 2) {
+            // H2 is a child of the current H1
+            if (currentH1) {
+                parentHash = currentH1.hash;
+                currentH1.children.push(hash);
+                contextTitle = `${plainText} (${currentH1.title})`;
+            }
+            currentH2 = newHeading;
+            currentH3 = null;
+        }
+        else if (level === 3) {
+            // H3 is a child of the current H2, or directly of H1 if no H2 exists
+            if (currentH2) {
+                parentHash = currentH2.hash;
+                currentH2.children.push(hash);
+                contextTitle = `${plainText} (${currentH2.title})`;
+            }
+            else if (currentH1) {
+                parentHash = currentH1.hash;
+                currentH1.children.push(hash);
+                contextTitle = `${plainText} (${currentH1.title})`;
+            }
+            currentH3 = newHeading;
+        }
+        // Check for duplicates before adding to TOC
         const existingTocIndex = tableOfContents.findIndex((toc) => toc.hash === hash);
         if (existingTocIndex === -1) {
-            // TOC 항목 추가
+            // Add new TOC entry
             tableOfContents.push({
                 type: block.type,
                 hash,

package/dist/util/tocHelper.d.ts

@@ -23,7 +23,7 @@ export declare const optimizeTocArray: (tocEntries: TocEntry[], reporter: Report
     buildHierarchy?: boolean;
 }) => TocEntry[];
 /**
- * TOC 구조의 유효성을 검사하고 문제가 있는 항목을 필터링
+ * Validates TOC structure and ensures proper parent-child relationships
  */
 export declare const validateTocStructure: (tocEntries: TocEntry[], reporter: Reporter) => TocEntry[];
 /**

package/dist/util/tocHelper.js

@@ -33,95 +33,42 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
         }
         return entry;
     });
-    // 구조적 유효성 검증 및 정리
+    // Validate structure and build hierarchy
     const validatedToc = (0, exports.validateTocStructure)(enrichedTocEntries, reporter);
     // Remove duplicates if requested
     let processedToc = validatedToc;
     if (removeDuplicates) {
         const startTime = Date.now();
-        // 중복 해시 및 타이틀 검사를 위한 맵
+        // Map to track unique entries by hash
         const uniqueMap = new Map();
-        // 섹션별 유효한 하위 항목 분류
-        const h1Entries = new Map(); // 최상위 항목
-        const childEntries = new Map(); // 상위 해시 -> 하위 해시 세트
-        // 1. 먼저 모든 H1 항목을 수집하고 맵에 저장
+        // First collect H1 entries (top-level sections)
         for (const entry of validatedToc) {
             if (entry.level === 1) {
-                h1Entries.set(entry.hash, entry);
-                childEntries.set(entry.hash, new Set());
+                uniqueMap.set(entry.hash, entry);
             }
         }
-        // 2. 각 항목을 처리하여 해시 기반으로 적절한 부모-자식 관계 검증
+        // Then collect child entries (H2, H3) that have valid parents
         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 (entry.level !== 1 && entry.parentHash) {
+                // Only add entries with valid parents to ensure proper hierarchy
+                const parentExists = uniqueMap.has(entry.parentHash) ||
+                    validatedToc.some((e) => e.hash === entry.parentHash);
                 if (parentExists) {
-                    // 부모에 이 항목을 자식으로 추가
-                    if (childEntries.has(entry.parentHash)) {
-                        childEntries.get(entry.parentHash).add(entry.hash);
+                    // Add to unique map if not already there
+                    if (!uniqueMap.has(entry.hash)) {
+                        uniqueMap.set(entry.hash, entry);
                     }
-                    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);
+                    reporter.warn(`Skipping orphaned TOC entry: ${entry.title}`);
                 }
             }
         }
-        // 여러 섹션에 동일한 제목의 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 = validatedToc.length - processedToc.length;
         const processTime = Date.now() - startTime;
         if (removedCount > 0) {
-            reporter.info(`Removed ${removedCount} duplicate/invalid TOC entries in ${processTime}ms.`);
+            reporter.info(`Removed ${removedCount} duplicate TOC entries in ${processTime}ms.`);
         }
     }
     // Add context to duplicate title entries for better display
@@ -135,14 +82,14 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
     }
     // Build the hierarchical structure if requested
     if (buildHierarchy) {
-        // First level sort - by level, then by approximate order
+        // Sort by level for proper hierarchy building
         processedToc.sort((a, b) => {
             if ((a.level || 0) !== (b.level || 0)) {
                 return (a.level || 0) - (b.level || 0);
             }
             return 0; // Keep original order for same level
         });
-        // 확인을 위한 로깅
+        // Log the TOC structure
         const h1Count = processedToc.filter((item) => item.level === 1).length;
         const h2Count = processedToc.filter((item) => item.level === 2).length;
         const h3Count = processedToc.filter((item) => item.level === 3).length;
@@ -152,103 +99,80 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
 };
 exports.optimizeTocArray = optimizeTocArray;
 /**
- * TOC 구조의 유효성을 검사하고 문제가 있는 항목을 필터링
+ * Validates TOC structure and ensures proper parent-child relationships
  */
 const validateTocStructure = (tocEntries, reporter) => {
     if (!tocEntries || tocEntries.length === 0) {
         return [];
     }
-    // 1. 섹션별 매핑 구성
-    const h1Map = new Map();
-    const h1Children = new Map();
-    // 2. 모든 H1 항목 수집
+    // Create maps for efficient lookups
+    const entryMap = new Map();
+    const h1Entries = new Map();
+    // First pass: collect entries by hash
     for (const entry of tocEntries) {
+        entryMap.set(entry.hash, entry);
+        // Collect H1 entries separately
         if (entry.level === 1) {
-            h1Map.set(entry.hash, entry);
-            h1Children.set(entry.hash, new Set());
+            h1Entries.set(entry.hash, entry);
         }
     }
-    // H1이 없으면 원본 반환
-    if (h1Map.size === 0) {
+    // No H1 entries? Return original
+    if (h1Entries.size === 0) {
         return tocEntries;
     }
-    // 3. 각 항목을 올바른 부모에 연결
+    // Track suspicious entries that might be duplicates
+    const suspiciousEntries = new Set();
+    // Second pass: check parent-child relationships
     for (const entry of tocEntries) {
         if (entry.level !== 1 && entry.parentHash) {
-            // 부모가 H1인 경우
-            if (h1Map.has(entry.parentHash)) {
-                h1Children.get(entry.parentHash).add(entry.hash);
+            // Check if parent exists
+            if (!entryMap.has(entry.parentHash)) {
+                suspiciousEntries.add(entry.hash);
+                reporter.warn(`Entry ${entry.title} has invalid parent reference`);
             }
         }
     }
-    // 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();
+    // Analyze entries with same title but different parents
+    const titleToEntries = 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);
-            }
+        const title = entry.title.toLowerCase();
+        if (!titleToEntries.has(title)) {
+            titleToEntries.set(title, []);
         }
-    }
-    // 여러 섹션에 동일한 제목의 항목이 있는지 검사
-    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);
+        titleToEntries.get(title).push(entry);
+    }
+    // Check for duplicate titles and mark suspicious if needed
+    for (const [title, entries] of titleToEntries.entries()) {
+        if (entries.length > 1) {
+            // Group entries by parent hash
+            const entriesByParent = new Map();
+            for (const entry of entries) {
+                const parentKey = entry.parentHash || "none";
+                if (!entriesByParent.has(parentKey)) {
+                    entriesByParent.set(parentKey, []);
+                }
+                entriesByParent.get(parentKey).push(entry);
+            }
+            // If same title appears under multiple parents
+            if (entriesByParent.size > 1) {
+                reporter.info(`Title "${title}" appears under ${entriesByParent.size} different parents`);
+                // For each parent, keep only the first occurrence
+                for (const [parentHash, parentEntries] of entriesByParent.entries()) {
+                    if (parentEntries.length > 1) {
+                        // Keep first entry, mark others as suspicious
+                        for (let i = 1; i < parentEntries.length; i++) {
+                            suspiciousEntries.add(parentEntries[i].hash);
                         }
                     }
                 }
             }
         }
     }
-    // 6. 의심스러운 항목 수 보고
+    // Report suspicious entries
     if (suspiciousEntries.size > 0) {
         reporter.info(`Found ${suspiciousEntries.size} suspicious TOC entries that might be duplicates`);
     }
-    // 7. 의심스러운 항목 제거된 결과 반환
+    // Return filtered TOC with suspicious entries removed
     return tocEntries.filter((entry) => !suspiciousEntries.has(entry.hash));
 };
 exports.validateTocStructure = validateTocStructure;

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