gatsby-source-notion-churnotion 1.1.28 → 1.1.29

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

@@ -0,0 +1,35 @@
+import { BaseContentBlock } from "notion-types";
+import { Actions, GatsbyCache, Reporter } from "gatsby";
+import { CustomImageBlock } from "../../types";
+export interface BlockProcessorContext {
+    actions: Actions;
+    getCache: (this: void, id: string) => GatsbyCache;
+    createNodeId: (this: void, input: string) => string;
+    reporter: Reporter;
+    cache: GatsbyCache;
+}
+export interface ProcessBlockResult {
+    thumbnail?: string | null;
+    plainText?: string;
+    updatedBlock?: BaseContentBlock;
+    tableOfContents?: {
+        type: string;
+        hash: string;
+        title: string;
+    }[];
+}
+export declare abstract class BlockProcessor {
+    protected context: BlockProcessorContext;
+    constructor(context: BlockProcessorContext);
+    abstract canProcess(block: BaseContentBlock): boolean;
+    abstract process(block: BaseContentBlock): Promise<ProcessBlockResult>;
+    protected extractPlainText(block: BaseContentBlock): string | null;
+    protected isTextContentBlock(block: BaseContentBlock): block is BaseContentBlock & {
+        [key in "paragraph" | "heading_1" | "heading_2" | "heading_3" | "quote" | "bulleted_list_item" | "numbered_list_item" | "callout" | "code" | "toggle" | "to_do" | "bookmark" | "table_of_contents" | "breadcrumb" | "divider" | "embed"]?: {
+            rich_text: {
+                plain_text: string;
+            }[];
+        };
+    };
+    protected isImageBlock(block: BaseContentBlock): block is CustomImageBlock;
+}

package/dist/util/blocks/blockProcessor.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockProcessor = void 0;
+class BlockProcessor {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    extractPlainText(block) {
+        if (this.isTextContentBlock(block)) {
+            const richTextArray = block[block.type]?.rich_text || [];
+            return richTextArray
+                .map((text) => block.type === "code" // code의 \n 제거
+                ? text.plain_text.replace(/\\n/g, "")
+                : text.plain_text)
+                .join(" ");
+        }
+        return null;
+    }
+    isTextContentBlock(block) {
+        return [
+            "paragraph",
+            "heading_1",
+            "heading_2",
+            "heading_3",
+            "quote",
+            "bulleted_list_item",
+            "numbered_list_item",
+            "callout",
+            "code",
+            "toggle",
+            "to_do",
+            "bookmark",
+            "table_of_contents",
+            "breadcrumb",
+            "divider",
+            "embed",
+        ].includes(block.type);
+    }
+    isImageBlock(block) {
+        return block.type === "image" && "image" in block;
+    }
+}
+exports.BlockProcessor = BlockProcessor;

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

@@ -0,0 +1,10 @@
+import { BaseContentBlock } from "notion-types";
+import { BlockProcessor, BlockProcessorContext, ProcessBlockResult } from "./blockProcessor";
+export declare class BlockProcessorRegistry {
+    private processors;
+    private context;
+    constructor(context: BlockProcessorContext);
+    private registerDefaultProcessors;
+    registerProcessor(processor: BlockProcessor): void;
+    processBlock(block: BaseContentBlock): Promise<ProcessBlockResult>;
+}

package/dist/util/blocks/blockProcessorRegistry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockProcessorRegistry = void 0;
+const textBlockProcessor_1 = require("./textBlockProcessor");
+const imageBlockProcessor_1 = require("./imageBlockProcessor");
+const mediaBlockProcessor_1 = require("./mediaBlockProcessor");
+const structureBlockProcessor_1 = require("./structureBlockProcessor");
+class BlockProcessorRegistry {
+    processors = [];
+    context;
+    constructor(context) {
+        this.context = context;
+        this.registerDefaultProcessors();
+    }
+    registerDefaultProcessors() {
+        // 기본 프로세서 등록
+        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 structureBlockProcessor_1.StructureBlockProcessor(this.context));
+    }
+    registerProcessor(processor) {
+        this.processors.push(processor);
+    }
+    async processBlock(block) {
+        for (const processor of this.processors) {
+            if (processor.canProcess(block)) {
+                return await processor.process(block);
+            }
+        }
+        // 어떤 프로세서도 처리할 수 없는 경우 (디버깅을 위해 타입 로그)
+        this.context.reporter.warn(`Unsupported block type: ${block.type}`);
+        // 기본 결과 반환
+        return {
+            updatedBlock: block,
+            plainText: "",
+        };
+    }
+}
+exports.BlockProcessorRegistry = BlockProcessorRegistry;

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

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

package/dist/util/blocks/imageBlockProcessor.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const gatsby_source_filesystem_1 = require("gatsby-source-filesystem");
+class ImageBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return this.isImageBlock(block);
+    }
+    async process(block) {
+        const { actions, getCache, createNodeId, reporter, cache } = this.context;
+        const { createNode } = actions;
+        const imageBlock = block;
+        if (block.type === "image" && "image" in block) {
+            const imageSourceType = imageBlock.image.type;
+            const imageUrl = imageSourceType === `external`
+                ? imageBlock.image.external?.url
+                : imageBlock.image?.file?.url;
+            if (!imageUrl)
+                return { updatedBlock: block };
+            // GIF 파일 처리
+            if (imageUrl.endsWith(".gif")) {
+                const staticDir = path_1.default.join(process.cwd(), "static"); // Gatsby의 static 디렉토리
+                const gifFileName = path_1.default.basename(imageUrl); // 파일 이름 추출
+                const gifFilePath = path_1.default.join(staticDir, gifFileName);
+                // 이미 static 디렉토리에 파일이 있는지 확인
+                if (!fs_extra_1.default.existsSync(gifFilePath)) {
+                    try {
+                        reporter.info(`[GIF PROCESSING] Downloading GIF: ${imageUrl}`);
+                        const response = await fetch(imageUrl);
+                        if (!response.ok) {
+                            throw new Error(`Failed to download GIF: ${response.statusText}`);
+                        }
+                        const arrayBuffer = await response.arrayBuffer();
+                        const buffer = Buffer.from(arrayBuffer);
+                        await fs_extra_1.default.ensureDir(staticDir); // static 디렉토리 생성
+                        await fs_extra_1.default.writeFile(gifFilePath, buffer); // GIF 파일 저장
+                        reporter.info(`[GIF SUCCESS] Saved GIF to static: ${gifFilePath}`);
+                    }
+                    catch (error) {
+                        reporter.warn(`[GIF WARNING] Failed to process GIF: ${imageUrl}`);
+                        return { updatedBlock: block };
+                    }
+                }
+                else {
+                    reporter.info(`[GIF CACHE HIT] GIF already exists: ${gifFilePath}`);
+                }
+                // GIF 파일을 정적 파일로 추가
+                const updatedBlock = {
+                    ...imageBlock,
+                    image: {
+                        fileId: gifFileName, // static 경로를 기준으로 참조
+                        caption: imageBlock.image.caption,
+                    },
+                };
+                return {
+                    updatedBlock: updatedBlock,
+                    thumbnail: gifFileName,
+                };
+            }
+            // GIF가 아닌 경우 기존 로직 유지
+            const cacheKey = `${imageUrl}-post-image`;
+            const cachedFileNodeId = await cache.get(cacheKey);
+            if (cachedFileNodeId) {
+                reporter.info(`[CACHE HIT] Image already processed: ${imageUrl}`);
+                const updatedBlock = {
+                    ...imageBlock,
+                    image: {
+                        fileId: cachedFileNodeId,
+                        caption: imageBlock.image.caption,
+                    },
+                };
+                return {
+                    updatedBlock: updatedBlock,
+                    thumbnail: cachedFileNodeId,
+                };
+            }
+            try {
+                const fileNode = await (0, gatsby_source_filesystem_1.createRemoteFileNode)({
+                    url: imageUrl,
+                    parentNodeId: block.id,
+                    getCache,
+                    createNode,
+                    createNodeId,
+                });
+                if (fileNode) {
+                    await cache.set(cacheKey, fileNode.id);
+                    const updatedBlock = {
+                        ...imageBlock,
+                        image: {
+                            fileId: fileNode.id,
+                            caption: imageBlock.image.caption,
+                        },
+                    };
+                    return {
+                        updatedBlock: updatedBlock,
+                        thumbnail: fileNode.id,
+                    };
+                }
+            }
+            catch (error) {
+                reporter.warn(`[WARNING] Failed to download or process image: ${imageUrl}`);
+            }
+        }
+        return { updatedBlock: block };
+    }
+}
+exports.ImageBlockProcessor = ImageBlockProcessor;

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

@@ -0,0 +1,6 @@
+export * from "./blockProcessor";
+export * from "./blockProcessorRegistry";
+export * from "./imageBlockProcessor";
+export * from "./mediaBlockProcessor";
+export * from "./structureBlockProcessor";
+export * from "./textBlockProcessor";

package/dist/util/blocks/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./blockProcessor"), exports);
+__exportStar(require("./blockProcessorRegistry"), exports);
+__exportStar(require("./imageBlockProcessor"), exports);
+__exportStar(require("./mediaBlockProcessor"), exports);
+__exportStar(require("./structureBlockProcessor"), exports);
+__exportStar(require("./textBlockProcessor"), exports);

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

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

package/dist/util/blocks/mediaBlockProcessor.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+class MediaBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return ["bookmark", "embed", "video", "audio", "pdf", "file"].includes(block.type);
+    }
+    async process(block) {
+        const { reporter } = this.context;
+        // 미디어 블록 타입 처리 로직
+        const blockType = block.type;
+        // 각 블록 타입에 맞는 특별한 처리가 필요한 경우 여기에 추가
+        switch (blockType) {
+            case "bookmark":
+                reporter.info(`Processing bookmark block: ${JSON.stringify(block.bookmark?.url)}`);
+                break;
+            case "embed":
+                reporter.info(`Processing embed block: ${JSON.stringify(block.embed?.url)}`);
+                break;
+            case "video":
+                reporter.info(`Processing video block with type: ${JSON.stringify(block.video?.type)}`);
+                break;
+            case "audio":
+                reporter.info(`Processing audio block with type: ${JSON.stringify(block.audio?.type)}`);
+                break;
+            case "pdf":
+                reporter.info(`Processing pdf block with type: ${JSON.stringify(block.pdf?.type)}`);
+                break;
+            case "file":
+                reporter.info(`Processing file block with type: ${JSON.stringify(block.file?.type)}`);
+                break;
+        }
+        // 블록의 텍스트 컨텐츠를 추출하려고 시도합니다.
+        let plainText = "";
+        // bookmark와 같은 일부 블록은 캡션에 텍스트가 있을 수 있습니다.
+        if (blockType === "bookmark" && block.bookmark?.caption) {
+            plainText = block.bookmark.caption
+                .map((item) => item.plain_text)
+                .join(" ");
+        }
+        return {
+            plainText,
+            updatedBlock: block,
+        };
+    }
+}
+exports.MediaBlockProcessor = MediaBlockProcessor;

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

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

package/dist/util/blocks/structureBlockProcessor.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+class StructureBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return [
+            "column",
+            "column_list",
+            "table",
+            "table_row",
+            "divider",
+            "breadcrumb",
+            "table_of_contents",
+            "equation",
+            "synced_block",
+            "template",
+            "link_to_page",
+            "link_preview",
+        ].includes(block.type);
+    }
+    async process(block) {
+        const { reporter } = this.context;
+        // 구조 블록 타입 처리 로직
+        const blockType = block.type;
+        // 각 블록 타입에 맞는 특별한 처리가 필요한 경우 여기에 추가
+        switch (blockType) {
+            case "column":
+                reporter.info(`Processing column block`);
+                break;
+            case "column_list":
+                reporter.info(`Processing column_list block`);
+                break;
+            case "table":
+                reporter.info(`Processing table block: table_width=${JSON.stringify(block.table?.table_width)}`);
+                break;
+            case "table_row":
+                const cellCount = block.table_row?.cells?.length || 0;
+                reporter.info(`Processing table_row block with ${cellCount} cells`);
+                break;
+            case "divider":
+                reporter.info(`Processing divider block`);
+                break;
+            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;
+            case "synced_block":
+                reporter.info(`Processing synced_block`);
+                break;
+            case "template":
+                reporter.info(`Processing template block`);
+                break;
+            case "link_to_page":
+                reporter.info(`Processing link_to_page block`);
+                break;
+            case "link_preview":
+                reporter.info(`Processing link_preview block: ${JSON.stringify(block.link_preview?.url)}`);
+                break;
+        }
+        // 일부 구조 블록은 텍스트를 포함할 수 있음
+        let plainText = "";
+        // 테이블 셀에서 텍스트 추출 예시
+        if (blockType === "table_row" && block.table_row?.cells) {
+            plainText = block.table_row.cells
+                .flat()
+                .map((cell) => cell.plain_text || "")
+                .join(" ");
+        }
+        return {
+            plainText,
+            updatedBlock: block,
+        };
+    }
+}
+exports.StructureBlockProcessor = StructureBlockProcessor;

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

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

package/dist/util/blocks/textBlockProcessor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextBlockProcessor = void 0;
+const blockProcessor_1 = require("./blockProcessor");
+const tableOfContent_1 = require("../tableOfContent");
+class TextBlockProcessor extends blockProcessor_1.BlockProcessor {
+    canProcess(block) {
+        return this.isTextContentBlock(block);
+    }
+    async process(block) {
+        const tableOfContents = [];
+        // 목차 처리
+        await (0, tableOfContent_1.processTableOfContents)(block, tableOfContents);
+        // 텍스트 추출
+        const plainText = this.extractPlainText(block);
+        return {
+            plainText: plainText || "",
+            updatedBlock: block,
+            tableOfContents: tableOfContents.length > 0 ? tableOfContents : undefined,
+        };
+    }
+}
+exports.TextBlockProcessor = TextBlockProcessor;

package/dist/util/processor.js

@@ -1,14 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processor = void 0;
-const gatsby_source_filesystem_1 = require("gatsby-source-filesystem");
 const metadataProcessor_1 = require("./metadataProcessor");
-const tableOfContent_1 = require("./tableOfContent");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
+const blocks_1 = require("./blocks");
 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);
@@ -16,154 +10,46 @@ const processor = async (blocks, actions, getCache, createNodeId, reporter, cach
 };
 exports.processor = processor;
 const processBlocksForContent = async (blocks, actions, getCache, createNodeId, reporter, cache) => {
+    const context = {
+        actions,
+        getCache,
+        createNodeId,
+        reporter,
+        cache,
+    };
+    // 블록 프로세서 레지스트리 생성
+    const processorRegistry = new blocks_1.BlockProcessorRegistry(context);
     const tableOfContents = [];
     let thumbnail = null;
     let rawText = "";
     const updatedBlocks = [];
-    let firstImageBlock = null;
-    for (const block of blocks) {
-        if (isImageBlock(block)) {
-            firstImageBlock = block;
-            break;
-        }
-    }
-    if (firstImageBlock) {
-        const updatedBlock = await processImageBlock(firstImageBlock, actions, getCache, createNodeId, reporter, cache);
-        if (updatedBlock?.image?.fileId) {
-            thumbnail = updatedBlock.image.fileId;
-        }
-        updatedBlocks[blocks.indexOf(firstImageBlock)] =
-            updatedBlock || firstImageBlock;
-    }
-    await Promise.all(blocks.map(async (block, index) => {
-        if (block === firstImageBlock)
-            return;
-        await (0, tableOfContent_1.processTableOfContents)(block, tableOfContents);
-        const plainText = extractPlainText(block);
-        if (plainText) {
-            rawText += plainText + " ";
-        }
-        if (isImageBlock(block)) {
-            const updatedBlock = await processImageBlock(block, actions, getCache, createNodeId, reporter, cache);
-            updatedBlocks[index] = updatedBlock || block;
+    // 첫 번째 이미지 블록을 찾아 썸네일로 사용
+    let firstImageIndex = blocks.findIndex((block) => block.type === "image");
+    // 블록 처리
+    const processResults = await Promise.all(blocks.map(async (block, index) => {
+        const result = await processorRegistry.processBlock(block);
+        // 썸네일 처리
+        if (index === firstImageIndex && result.thumbnail) {
+            thumbnail = result.thumbnail;
+        }
+        // 텍스트 데이터 추가
+        if (result.plainText) {
+            rawText += result.plainText + " ";
+        }
+        // 목차 데이터 추가
+        if (result.tableOfContents) {
+            tableOfContents.push(...result.tableOfContents);
+        }
+        return result;
+    }));
+    // 업데이트된 블록 적용
+    processResults.forEach((result, index) => {
+        if (result.updatedBlock) {
+            updatedBlocks[index] = result.updatedBlock;
         }
         else {
-            updatedBlocks[index] = block;
+            updatedBlocks[index] = blocks[index];
         }
-    }));
+    });
     return { thumbnail, tableOfContents, updatedBlocks, rawText };
 };
-const isTextContentBlock = (block) => {
-    return [
-        "paragraph",
-        "heading_1",
-        "heading_2",
-        "heading_3",
-        "quote",
-        "bulleted_list_item",
-        "numbered_list_item",
-        "callout",
-        "code",
-    ].includes(block.type);
-};
-const extractPlainText = (block) => {
-    if (isTextContentBlock(block)) {
-        const richTextArray = block[block.type]?.rich_text || [];
-        return richTextArray
-            .map((text) => block.type === "code" // code의 \n 제거
-            ? text.plain_text.replace(/\\n/g, "")
-            : text.plain_text)
-            .join(" ");
-    }
-    return null;
-};
-const isImageBlock = (block) => {
-    return block.type === "image" && "image" in block;
-};
-const processImageBlock = async (block, actions, getCache, createNodeId, reporter, cache) => {
-    const { createNode } = actions;
-    if (block.type === "image" && "image" in block) {
-        const imageSourceType = block.image.type;
-        const imageUrl = imageSourceType === `external`
-            ? block.image.external?.url
-            : block.image?.file?.url;
-        if (!imageUrl)
-            return null;
-        // GIF 파일 처리
-        if (imageUrl.endsWith(".gif")) {
-            const staticDir = path_1.default.join(process.cwd(), "static"); // Gatsby의 static 디렉토리
-            const gifFileName = path_1.default.basename(imageUrl); // 파일 이름 추출
-            const gifFilePath = path_1.default.join(staticDir, gifFileName);
-            // 이미 static 디렉토리에 파일이 있는지 확인
-            if (!fs_extra_1.default.existsSync(gifFilePath)) {
-                try {
-                    reporter.info(`[GIF PROCESSING] Downloading GIF: ${imageUrl}`);
-                    const response = await fetch(imageUrl);
-                    if (!response.ok) {
-                        throw new Error(`Failed to download GIF: ${response.statusText}`);
-                    }
-                    const arrayBuffer = await response.arrayBuffer();
-                    const buffer = Buffer.from(arrayBuffer);
-                    await fs_extra_1.default.ensureDir(staticDir); // static 디렉토리 생성
-                    await fs_extra_1.default.writeFile(gifFilePath, buffer); // GIF 파일 저장
-                    reporter.info(`[GIF SUCCESS] Saved GIF to static: ${gifFilePath}`);
-                }
-                catch (error) {
-                    reporter.warn(`[GIF WARNING] Failed to process GIF: ${imageUrl}`);
-                    return null;
-                }
-            }
-            else {
-                reporter.info(`[GIF CACHE HIT] GIF already exists: ${gifFilePath}`);
-            }
-            // GIF 파일을 정적 파일로 추가
-            const updatedBlock = {
-                ...block,
-                image: {
-                    fileId: gifFileName, // static 경로를 기준으로 참조
-                    caption: block.image.caption,
-                },
-            };
-            return updatedBlock;
-        }
-        // GIF가 아닌 경우 기존 로직 유지
-        const cacheKey = `${imageUrl}-post-image`;
-        const cachedFileNodeId = await cache.get(cacheKey);
-        if (cachedFileNodeId) {
-            reporter.info(`[CACHE HIT] Image already processed: ${imageUrl}`);
-            const updatedBlock = {
-                ...block,
-                image: {
-                    fileId: cachedFileNodeId,
-                    caption: block.image.caption,
-                },
-            };
-            return updatedBlock;
-        }
-        try {
-            const fileNode = await (0, gatsby_source_filesystem_1.createRemoteFileNode)({
-                url: imageUrl,
-                parentNodeId: block.id,
-                getCache,
-                createNode,
-                createNodeId,
-            });
-            if (fileNode) {
-                const updatedBlock = {
-                    ...block,
-                    image: {
-                        fileId: fileNode.id,
-                        caption: block.image.caption,
-                    },
-                };
-                reporter.info(`[SUCCESS] Image processed: ${fileNode.id}`);
-                await cache.set(cacheKey, fileNode.id);
-                return updatedBlock;
-            }
-        }
-        catch (error) {
-            reporter.warn(`[WARNING] Failed to download image: ${imageUrl}`);
-        }
-    }
-    return null;
-};