gatsby-source-notion-churnotion 1.2.2 → 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/blocks/blockProcessor.d.ts

@@ -1,6 +1,7 @@
 import { BaseContentBlock } from "notion-types";
 import { Actions, GatsbyCache, Reporter } from "gatsby";
 import { CustomImageBlock } from "../../types";
+import { TocEntry } from "../tocHelper";
 export interface BlockProcessorContext {
     actions: Actions;
     getCache: (this: void, id: string) => GatsbyCache;
@@ -12,11 +13,7 @@ export interface ProcessBlockResult {
     thumbnail?: string | null;
     plainText?: string;
     updatedBlock?: BaseContentBlock;
-    tableOfContents?: {
-        type: string;
-        hash: string;
-        title: string;
-    }[];
+    tableOfContents?: TocEntry[];
 }
 export declare abstract class BlockProcessor {
     protected context: BlockProcessorContext;

package/dist/util/blocks/blockProcessorRegistry.js

@@ -5,6 +5,7 @@ const textBlockProcessor_1 = require("./textBlockProcessor");
 const imageBlockProcessor_1 = require("./imageBlockProcessor");
 const mediaBlockProcessor_1 = require("./mediaBlockProcessor");
 const structureBlockProcessor_1 = require("./structureBlockProcessor");
+const tableOfContentsBlockProcessor_1 = require("./tableOfContentsBlockProcessor");
 class BlockProcessorRegistry {
     processors = [];
     context;
@@ -17,6 +18,7 @@ class BlockProcessorRegistry {
         this.registerProcessor(new textBlockProcessor_1.TextBlockProcessor(this.context));
         this.registerProcessor(new imageBlockProcessor_1.ImageBlockProcessor(this.context));
         this.registerProcessor(new mediaBlockProcessor_1.MediaBlockProcessor(this.context));
+        this.registerProcessor(new tableOfContentsBlockProcessor_1.TableOfContentsBlockProcessor(this.context));
         this.registerProcessor(new structureBlockProcessor_1.StructureBlockProcessor(this.context));
     }
     registerProcessor(processor) {

package/dist/util/blocks/index.d.ts

@@ -4,3 +4,4 @@ export * from "./imageBlockProcessor";
 export * from "./mediaBlockProcessor";
 export * from "./structureBlockProcessor";
 export * from "./textBlockProcessor";
+export * from "./tableOfContentsBlockProcessor";

package/dist/util/blocks/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./imageBlockProcessor"), exports);
 __exportStar(require("./mediaBlockProcessor"), exports);
 __exportStar(require("./structureBlockProcessor"), exports);
 __exportStar(require("./textBlockProcessor"), exports);
+__exportStar(require("./tableOfContentsBlockProcessor"), exports);

package/dist/util/blocks/structureBlockProcessor.js

@@ -11,7 +11,6 @@ class StructureBlockProcessor extends blockProcessor_1.BlockProcessor {
             "table_row",
             "divider",
             "breadcrumb",
-            "table_of_contents",
             "equation",
             "synced_block",
             "template",
@@ -44,9 +43,6 @@ class StructureBlockProcessor extends blockProcessor_1.BlockProcessor {
             case "breadcrumb":
                 reporter.info(`Processing breadcrumb block`);
                 break;
-            case "table_of_contents":
-                reporter.info(`Processing table_of_contents block`);
-                break;
             case "equation":
                 reporter.info(`Processing equation block: ${JSON.stringify(block.equation?.expression)}`);
                 break;

package/dist/util/blocks/tableOfContentsBlockProcessor.d.ts

@@ -0,0 +1,6 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, ProcessBlockResult } from "./blockProcessor";
+export declare class TableOfContentsBlockProcessor extends BlockProcessor {
+    canProcess(block: BaseContentBlock): boolean;
+    process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/tableOfContentsBlockProcessor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableOfContentsBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+class TableOfContentsBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return block.type === "table_of_contents";
+    }
+    async process(block) {
+        const { reporter } = this.context;
+        reporter.info(`Processing table_of_contents block with id: ${block.id}`);
+        // Table of contents blocks don't have any content by themselves
+        // They are used as placeholders, and the actual TOC data is generated separately
+        // and passed through the GraphQL schema
+        return {
+            plainText: "",
+            updatedBlock: block,
+            // We don't return tableOfContents from here because that's handled
+            // at a higher level in the processor.ts file
+        };
+    }
+}
+exports.TableOfContentsBlockProcessor = TableOfContentsBlockProcessor;

package/dist/util/processor.d.ts

@@ -1,7 +1,4 @@
 import { Actions, GatsbyCache, Reporter } from "gatsby";
 import { BaseContentBlock } from "notion-types";
-export declare const processor: (blocks: BaseContentBlock[], actions: Actions, getCache: (this: void, id: string) => GatsbyCache, createNodeId: (this: void, input: string) => string, reporter: Reporter, cache: GatsbyCache) => Promise<[string | null, {
-    type: string;
-    hash: string;
-    title: string;
-}[], BaseContentBlock[], string]>;
+import { TocEntry } from "./tocHelper";
+export declare const processor: (blocks: BaseContentBlock[], actions: Actions, getCache: (this: void, id: string) => GatsbyCache, createNodeId: (this: void, input: string) => string, reporter: Reporter, cache: GatsbyCache) => Promise<[string | null, TocEntry[], BaseContentBlock[], string]>;

package/dist/util/processor.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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);
@@ -17,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 = [];
@@ -42,6 +46,8 @@ const processBlocksForContent = async (blocks, actions, getCache, createNodeId,
         }
         return result;
     }));
+    // 목차 최적화
+    const processedToc = (0, tocHelper_1.optimizeTocArray)(tableOfContents, reporter);
     // 업데이트된 블록 적용
     processResults.forEach((result, index) => {
         if (result.updatedBlock) {
@@ -51,5 +57,5 @@ const processBlocksForContent = async (blocks, actions, getCache, createNodeId,
             updatedBlocks[index] = blocks[index];
         }
     });
-    return { thumbnail, tableOfContents, updatedBlocks, rawText };
+    return { thumbnail, tableOfContents: processedToc, updatedBlocks, rawText };
 };

package/dist/util/tableOfContent.d.ts

@@ -1,6 +1,4 @@
 import { BaseContentBlock } from "notion-types";
-export declare const processTableOfContents: (block: BaseContentBlock, tableOfContents: {
-    type: string;
-    hash: string;
-    title: string;
-}[]) => Promise<void>;
+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,22 +1,80 @@
 "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 || "";
-        const hash = `link-${plainText
-            .replace(/[^a-zA-Z0-9가-힣\s-_]/g, "")
-            .trim()
-            .replace(/\s+/g, "-")
-            .toLowerCase()}-${(0, crypto_1.randomUUID)().substring(0, 4)}`;
+        // 부모 컨텍스트 추가
+        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(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)}`;
+            hashCache.set(contextualId, hash);
+        }
+        // 현재 해시 저장
+        if (block.type === "heading_1") {
+            lastH1Hash = hash;
+        }
+        else if (block.type === "heading_2") {
+            lastH2Hash = hash;
+        }
         block.hash = hash;
-        tableOfContents.push({
-            type: block.type,
-            hash,
-            title: plainText,
-        });
+        // 중복 체크 - 동일한 hash가 이미 존재하는지 확인
+        const existingTocIndex = tableOfContents.findIndex((toc) => toc.hash === hash);
+        if (existingTocIndex === -1) {
+            tableOfContents.push({
+                type: block.type,
+                hash,
+                title: plainText,
+                parentHash,
+                level,
+            });
+        }
     }
 };
 exports.processTableOfContents = processTableOfContents;

package/dist/util/tocHelper.d.ts

@@ -0,0 +1,27 @@
+import { Reporter } from "gatsby";
+/**
+ * TocEntry interface representing a table of contents entry
+ */
+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 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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichDuplicateTitles = exports.optimizeTocArray = void 0;
+/**
+ * Utility function to efficiently handle large table of contents arrays
+ * 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 [];
+    }
+    // Track memory usage for large TOCs
+    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 = enrichedTocEntries;
+    if (removeDuplicates) {
+        const startTime = Date.now();
+        const uniqueMap = new Map();
+        // 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 = enrichedTocEntries.length - processedToc.length;
+        const processTime = Date.now() - startTime;
+        if (removedCount > 0) {
+            reporter.info(`Removed ${removedCount} duplicate TOC entries in ${processTime}ms.`);
+        }
+    }
+    // Limit size if necessary
+    if (processedToc.length > maxSize) {
+        reporter.warn(`Table of contents exceeds maximum size (${processedToc.length} > ${maxSize}). Truncating.`);
+        processedToc = processedToc.slice(0, maxSize);
+    }
+    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.2",
+  "version": "1.2.4",
   "skipLibCheck": true,
   "license": "0BSD",
   "main": "./dist/gatsby-node.js",