gatsby-source-notion-churnotion 1.2.3 → 1.2.4

package/dist/createSchemaCustomization.js

@@ -133,7 +133,7 @@ const createSchemaCustomization = ({ actions, schema }) => {
             version: Int
             description: String
             slug: String
-            tableOfContents: [JSON]
+            tableOfContents: [TocEntry]
             category_list: [${constants_1.NODE_TYPE.Category}]
             url: String!
             thumbnail: File @link(by: "id", from: "thumbnail")
@@ -160,6 +160,15 @@ const createSchemaCustomization = ({ actions, schema }) => {
         type ${constants_1.NODE_TYPE.RelatedPost} implements Node {
             posts: [${constants_1.NODE_TYPE.Post}] @link(by: "id")
         }
+
+        type TocEntry {
+            type: String!
+            hash: String!
+            title: String!
+            parentHash: String
+            level: Int
+            contextTitle: String
+        }
     `,
     ]);
 };

package/dist/util/processor.js

@@ -4,6 +4,7 @@ exports.processor = void 0;
 const metadataProcessor_1 = require("./metadataProcessor");
 const blocks_1 = require("./blocks");
 const tocHelper_1 = require("./tocHelper");
+const tableOfContent_1 = require("./tableOfContent");
 const processor = async (blocks, actions, getCache, createNodeId, reporter, cache) => {
     const { thumbnail, tableOfContents, updatedBlocks, rawText } = await processBlocksForContent(blocks, actions, getCache, createNodeId, reporter, cache);
     await (0, metadataProcessor_1.processMetadata)(blocks, actions, createNodeId, reporter, cache);
@@ -18,6 +19,8 @@ const processBlocksForContent = async (blocks, actions, getCache, createNodeId,
         reporter,
         cache,
     };
+    // 목차 컨텍스트 초기화
+    (0, tableOfContent_1.resetTocContext)();
     // 블록 프로세서 레지스트리 생성
     const processorRegistry = new blocks_1.BlockProcessorRegistry(context);
     const tableOfContents = [];

package/dist/util/tableOfContent.d.ts

@@ -1,3 +1,4 @@
 import { BaseContentBlock } from "notion-types";
 import { TocEntry } from "./tocHelper";
+export declare const resetTocContext: () => void;
 export declare const processTableOfContents: (block: BaseContentBlock, tableOfContents: TocEntry[]) => Promise<void>;

package/dist/util/tableOfContent.js

@@ -1,17 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processTableOfContents = void 0;
+exports.processTableOfContents = exports.resetTocContext = void 0;
 const crypto_1 = require("crypto");
 // Hash 생성 시 사용할 캐시
 const hashCache = new Map();
+// 헤딩 레벨 트래킹을 위한 변수들
+let lastH1Hash = "";
+let lastH2Hash = "";
+let lastH1Title = "";
+let lastH2Title = "";
+const resetTocContext = () => {
+    lastH1Hash = "";
+    lastH2Hash = "";
+    lastH1Title = "";
+    lastH2Title = "";
+};
+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 || "";
+        // 부모 컨텍스트 추가
+        let contextualId = plainText;
+        let parentHash = "";
+        let level = 0;
+        // 상위 헤딩에 따라 컨텍스트 저장
+        if (block.type === "heading_1") {
+            lastH1Title = plainText;
+            lastH2Title = "";
+            contextualId = `h1-${plainText}`;
+            level = 1;
+            // heading_1은 최상위 레벨이므로 부모가 없음
+        }
+        else if (block.type === "heading_2") {
+            lastH2Title = plainText;
+            contextualId = `h2-${lastH1Title}-${plainText}`;
+            parentHash = lastH1Hash; // heading_2의 부모는 가장 최근의 heading_1
+            level = 2;
+        }
+        else if (block.type === "heading_3") {
+            contextualId = `h3-${lastH1Title}-${lastH2Title}-${plainText}`;
+            parentHash = lastH2Hash || lastH1Hash; // heading_3의 부모는 가장 최근의 heading_2, 없으면 heading_1
+            level = 3;
+        }
         // 이미 처리된 플레인텍스트인지 확인
         let hash;
-        if (hashCache.has(plainText)) {
-            hash = hashCache.get(plainText);
+        if (hashCache.has(contextualId)) {
+            hash = hashCache.get(contextualId);
         }
         else {
             hash = `link-${plainText
@@ -19,7 +54,14 @@ const processTableOfContents = async (block, tableOfContents) => {
                 .trim()
                 .replace(/\s+/g, "-")
                 .toLowerCase()}-${(0, crypto_1.randomUUID)().substring(0, 4)}`;
-            hashCache.set(plainText, hash);
+            hashCache.set(contextualId, hash);
+        }
+        // 현재 해시 저장
+        if (block.type === "heading_1") {
+            lastH1Hash = hash;
+        }
+        else if (block.type === "heading_2") {
+            lastH2Hash = hash;
         }
         block.hash = hash;
         // 중복 체크 - 동일한 hash가 이미 존재하는지 확인
@@ -29,6 +71,8 @@ const processTableOfContents = async (block, tableOfContents) => {
                 type: block.type,
                 hash,
                 title: plainText,
+                parentHash,
+                level,
             });
         }
     }

package/dist/util/tocHelper.d.ts

@@ -6,13 +6,22 @@ export interface TocEntry {
     type: string;
     hash: string;
     title: string;
+    parentHash?: string;
+    level?: number;
+    contextTitle?: string;
 }
 /**
  * Utility function to efficiently handle large table of contents arrays
- * by removing duplicates and optionally limiting size
+ * by removing duplicates and optionally limiting size while preserving hierarchy
  */
 export declare const optimizeTocArray: (tocEntries: TocEntry[], reporter: Reporter, options?: {
     maxSize?: number;
     warnThreshold?: number;
     removeDuplicates?: boolean;
+    structureByLevel?: boolean;
+    enhanceDuplicates?: boolean;
 }) => TocEntry[];
+/**
+ * Enhances TOC entries with contextual titles to disambiguate duplicate titles
+ */
+export declare const enrichDuplicateTitles: (tocEntries: TocEntry[], reporter: Reporter) => void;

package/dist/util/tocHelper.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.optimizeTocArray = void 0;
+exports.enrichDuplicateTitles = exports.optimizeTocArray = void 0;
 /**
  * Utility function to efficiently handle large table of contents arrays
- * by removing duplicates and optionally limiting size
+ * by removing duplicates and optionally limiting size while preserving hierarchy
  */
 const optimizeTocArray = (tocEntries, reporter, options = {}) => {
     const { maxSize = 1000, // Maximum entries to include
     warnThreshold = 300, // Threshold to issue warning
     removeDuplicates = true, // Whether to remove duplicates
+    structureByLevel = true, // Whether to structure by heading level
+    enhanceDuplicates = true, // Whether to enhance duplicate titles with context
      } = options;
     if (!tocEntries || tocEntries.length === 0) {
         return [];
@@ -17,17 +19,40 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
     if (tocEntries.length > warnThreshold) {
         reporter.warn(`Large table of contents detected (${tocEntries.length} items). This might affect performance.`);
     }
+    // Enrich TOC entries with level information if not present
+    const enrichedTocEntries = tocEntries.map((entry) => {
+        if (!entry.level) {
+            const level = entry.type === "heading_1"
+                ? 1
+                : entry.type === "heading_2"
+                    ? 2
+                    : entry.type === "heading_3"
+                        ? 3
+                        : 0;
+            return { ...entry, level };
+        }
+        return entry;
+    });
+    // Sort by appearance (using array index as proxy) and then by level
+    enrichedTocEntries.sort((a, b) => {
+        // Sort by level to ensure headers are properly nested
+        return (a.level || 0) - (b.level || 0);
+    });
+    // Add context to duplicate title entries for better display
+    if (enhanceDuplicates) {
+        (0, exports.enrichDuplicateTitles)(enrichedTocEntries, reporter);
+    }
     // Remove duplicates if requested
-    let processedToc = tocEntries;
+    let processedToc = enrichedTocEntries;
     if (removeDuplicates) {
         const startTime = Date.now();
         const uniqueMap = new Map();
-        // Use a map for faster duplicate removal - O(n) instead of O(n²)
-        for (const entry of tocEntries) {
+        // Use the hash to ensure uniqueness, but preserve context when display titles are the same
+        for (const entry of enrichedTocEntries) {
             uniqueMap.set(entry.hash, entry);
         }
         processedToc = Array.from(uniqueMap.values());
-        const removedCount = tocEntries.length - processedToc.length;
+        const removedCount = enrichedTocEntries.length - processedToc.length;
         const processTime = Date.now() - startTime;
         if (removedCount > 0) {
             reporter.info(`Removed ${removedCount} duplicate TOC entries in ${processTime}ms.`);
@@ -41,3 +66,49 @@ const optimizeTocArray = (tocEntries, reporter, options = {}) => {
     return processedToc;
 };
 exports.optimizeTocArray = optimizeTocArray;
+/**
+ * Enhances TOC entries with contextual titles to disambiguate duplicate titles
+ */
+const enrichDuplicateTitles = (tocEntries, reporter) => {
+    if (!tocEntries || tocEntries.length === 0)
+        return;
+    // Find duplicate titles
+    const titleCounts = new Map();
+    const duplicateTitles = new Set();
+    // Count occurrences of each title
+    for (const entry of tocEntries) {
+        const count = (titleCounts.get(entry.title) || 0) + 1;
+        titleCounts.set(entry.title, count);
+        if (count > 1) {
+            duplicateTitles.add(entry.title);
+        }
+    }
+    if (duplicateTitles.size === 0)
+        return;
+    reporter.info(`Found ${duplicateTitles.size} duplicate title(s) in TOC. Adding context...`);
+    // Build parent map for fast lookups
+    const entryMap = new Map();
+    for (const entry of tocEntries) {
+        entryMap.set(entry.hash, entry);
+    }
+    // Create a hierarchical map to find parents
+    for (const entry of tocEntries) {
+        if (duplicateTitles.has(entry.title)) {
+            let context = "";
+            let parentEntry;
+            // Find parent context
+            if (entry.parentHash && entryMap.has(entry.parentHash)) {
+                parentEntry = entryMap.get(entry.parentHash);
+                context = parentEntry?.title || "";
+            }
+            // Add context to title
+            if (context) {
+                entry.contextTitle = `${entry.title} (${context})`;
+            }
+            else {
+                entry.contextTitle = entry.title;
+            }
+        }
+    }
+};
+exports.enrichDuplicateTitles = enrichDuplicateTitles;

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