npm - @8btc/ppt-generator-mcp - Versions diffs - 0.0.1 - Mend

@8btc/ppt-generator-mcp 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/README.md +129 -0
package/dist/export-pptx.d.ts +6 -0
package/dist/export-pptx.js +876 -0
package/dist/generate-ppt-slides.d.ts +10 -0
package/dist/generate-ppt-slides.js +581 -0
package/dist/index.d.ts +1 -0
package/dist/index.js +161 -0
package/dist/ppt-generator.d.ts +39 -0
package/dist/ppt-generator.js +110 -0
package/dist/tpls/imgs.json +482 -0
package/dist/tpls/tpl-1.json +7649 -0
package/dist/tpls/tpl-2.json +7455 -0
package/dist/tpls/tpl-3.json +8184 -0
package/dist/tpls/tpl-4.json +8352 -0
package/dist/types/outline.d.ts +36 -0
package/dist/types/outline.js +2 -0
package/dist/types/slide.d.ts +696 -0
package/dist/types/slide.js +2 -0
package/dist/utils/element.d.ts +94 -0
package/dist/utils/element.js +239 -0
package/dist/utils/htmlParser/format.d.ts +3 -0
package/dist/utils/htmlParser/format.js +47 -0
package/dist/utils/htmlParser/index.d.ts +4 -0
package/dist/utils/htmlParser/index.js +15 -0
package/dist/utils/htmlParser/lexer.d.ts +2 -0
package/dist/utils/htmlParser/lexer.js +245 -0
package/dist/utils/htmlParser/parser.d.ts +15 -0
package/dist/utils/htmlParser/parser.js +117 -0
package/dist/utils/htmlParser/stringify.d.ts +3 -0
package/dist/utils/htmlParser/stringify.js +32 -0
package/dist/utils/htmlParser/tags.d.ts +8 -0
package/dist/utils/htmlParser/tags.js +50 -0
package/dist/utils/htmlParser/types.d.ts +55 -0
package/dist/utils/htmlParser/types.js +2 -0
package/dist/utils/svg2Base64.d.ts +1 -0
package/dist/utils/svg2Base64.js +58 -0
package/dist/utils/svgPathParser.d.ts +120 -0
package/dist/utils/svgPathParser.js +145 -0
package/package.json +59 -0

package/dist/generate-ppt-slides.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { Outline } from "./types/outline";
+import { Slide } from "./types/slide";
+interface ImgPoolItem {
+    id: string;
+    src: string;
+    width: number;
+    height: number;
+}
+export declare const generatePPTSlides: (templateSlides: Slide[], outlineList: Outline[], imgs?: ImgPoolItem[]) => Slide[];
+export {};

package/dist/generate-ppt-slides.js ADDED Viewed

@@ -0,0 +1,581 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePPTSlides = void 0;
+const crypto_1 = require("crypto");
+const canvas_1 = require("@napi-rs/canvas");
+// Node.js环境DOM支持
+if (typeof window === "undefined") {
+    const { JSDOM } = require("jsdom");
+    const dom = new JSDOM("<!DOCTYPE html><html><body></body></html>");
+    global.DOMParser = dom.window.DOMParser;
+    global.document = dom.window.document;
+    global.NodeFilter = dom.window.NodeFilter;
+}
+// 生成随机ID的函数
+const nanoid = (length = 10) => {
+    return (0, crypto_1.randomBytes)(Math.ceil(length / 2))
+        .toString("hex")
+        .slice(0, length);
+};
+const generatePPTSlides = (templateSlides, outlineList, imgs = []) => {
+    const slides = [];
+    const coverTemplates = [];
+    const contentsTemplates = [];
+    const transitionTemplates = [];
+    const contentTemplates = [];
+    const endTemplates = [];
+    templateSlides.forEach((slide) => {
+        if (slide.type === "cover")
+            coverTemplates.push(slide);
+        else if (slide.type === "contents")
+            contentsTemplates.push(slide);
+        else if (slide.type === "transition")
+            transitionTemplates.push(slide);
+        else if (slide.type === "content")
+            contentTemplates.push(slide);
+        else if (slide.type === "end")
+            endTemplates.push(slide);
+    });
+    const normalizedOutlineList = formatOutlineList(outlineList, contentsTemplates);
+    let transitionIndex = 1;
+    // 章节过渡页模板
+    const transitionTemplate = transitionTemplates[Math.floor(Math.random() * transitionTemplates.length)];
+    for (const outlineItem of normalizedOutlineList) {
+        if (outlineItem.type === "cover") {
+            const coverSlide = generateCover(outlineItem, imgs, coverTemplates);
+            slides.push(coverSlide);
+        }
+        else if (outlineItem.type === "contents") {
+            const contentsSlide = generateContents(outlineItem, imgs, contentsTemplates);
+            slides.push(contentsSlide);
+        }
+        else if (outlineItem.type === "transition") {
+            const transitionSlide = generateTransition(outlineItem, imgs, transitionTemplate, transitionIndex);
+            slides.push(transitionSlide);
+            transitionIndex += 1;
+        }
+        else if (outlineItem.type === "content") {
+            const contentSlide = generateContent(outlineItem, imgs, contentTemplates);
+            slides.push(contentSlide);
+        }
+        else if (outlineItem.type === "end") {
+            const endSlide = generateEnd(outlineItem, imgs, endTemplates);
+            slides.push(endSlide);
+        }
+    }
+    return slides;
+};
+exports.generatePPTSlides = generatePPTSlides;
+const formatOutlineList = (outlineList, contentsTemplates) => {
+    const normalizedOutlineList = [];
+    const maxContentsCount = contentsTemplates.reduce((acc, cur) => {
+        const count = cur.elements.filter((el) => checkTextType(el, "item")).length;
+        acc = Math.max(acc, count);
+        return acc;
+    }, 0);
+    for (const outlineItem of outlineList) {
+        if (outlineItem.type === "content") {
+            const items = outlineItem.data.items;
+            if (items.length === 5 || items.length === 6) {
+                const items1 = items.slice(0, 3);
+                const items2 = items.slice(3);
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items1 },
+                });
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items2 },
+                    offset: 3,
+                });
+            }
+            else if (items.length === 7 || items.length === 8) {
+                const items1 = items.slice(0, 4);
+                const items2 = items.slice(4);
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items1 },
+                });
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items2 },
+                    offset: 4,
+                });
+            }
+            else if (items.length === 9 || items.length === 10) {
+                const items1 = items.slice(0, 3);
+                const items2 = items.slice(3, 6);
+                const items3 = items.slice(6);
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items1 },
+                });
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items2 },
+                    offset: 3,
+                });
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items3 },
+                    offset: 6,
+                });
+            }
+            else if (items.length > 10) {
+                const items1 = items.slice(0, 4);
+                const items2 = items.slice(4, 8);
+                const items3 = items.slice(8);
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items1 },
+                });
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items2 },
+                    offset: 4,
+                });
+                normalizedOutlineList.push({
+                    ...outlineItem,
+                    data: { ...outlineItem.data, items: items3 },
+                    offset: 8,
+                });
+            }
+            else {
+                normalizedOutlineList.push(outlineItem);
+            }
+        }
+        else if (outlineItem.type === "contents") {
+            const items = outlineItem.data.items;
+            if (items.length > maxContentsCount) {
+                const loop = Math.ceil(items.length / maxContentsCount);
+                for (let i = 0; i < loop; i++) {
+                    const items1 = items.slice(i * maxContentsCount, (i + 1) * maxContentsCount);
+                    normalizedOutlineList.push({
+                        ...outlineItem,
+                        data: { ...outlineItem.data, items: items1 },
+                        offset: i * maxContentsCount,
+                    });
+                }
+            }
+            else {
+                normalizedOutlineList.push(outlineItem);
+            }
+        }
+        else
+            normalizedOutlineList.push(outlineItem);
+    }
+    return normalizedOutlineList;
+};
+const generateCover = (outlineItem, imgs, coverTemplates) => {
+    const coverTemplate = coverTemplates[Math.floor(Math.random() * coverTemplates.length)];
+    const elements = coverTemplate.elements.map((el) => {
+        if (el.type === "image")
+            return getNewImgElement(el, imgs);
+        if (el.type !== "text" && el.type !== "shape")
+            return el;
+        if (checkTextType(el, "title") && outlineItem.data.title) {
+            return getNewTextElement({
+                el,
+                text: outlineItem.data.title,
+                maxLine: 1,
+            });
+        }
+        if (checkTextType(el, "content") && outlineItem.data.text) {
+            return getNewTextElement({
+                el,
+                text: outlineItem.data.text,
+                maxLine: 3,
+            });
+        }
+        return el;
+    });
+    return {
+        ...coverTemplate,
+        id: `${coverTemplate.id}-${nanoid(10)}`,
+        elements,
+    };
+};
+const generateContents = (outlineItem, imgs, contentsTemplates) => {
+    const _contentsTemplates = getUseableTemplates(contentsTemplates, outlineItem.data.items.length, "item");
+    const contentsTemplate = _contentsTemplates[Math.floor(Math.random() * _contentsTemplates.length)];
+    const sortedNumberItems = contentsTemplate.elements.filter((el) => checkTextType(el, "itemNumber"));
+    const sortedNumberItemIds = sortedNumberItems
+        .sort((a, b) => {
+        if (sortedNumberItems.length > 6) {
+            let aContent = "";
+            let bContent = "";
+            if (a.type === "text")
+                aContent = a.content;
+            if (a.type === "shape")
+                aContent = a.text.content;
+            if (b.type === "text")
+                bContent = b.content;
+            if (b.type === "shape")
+                bContent = b.text.content;
+            if (aContent && bContent) {
+                const aIndex = parseInt(aContent);
+                const bIndex = parseInt(bContent);
+                return aIndex - bIndex;
+            }
+        }
+        const aIndex = a.left + a.top * 2;
+        const bIndex = b.left + b.top * 2;
+        return aIndex - bIndex;
+    })
+        .map((el) => el.id);
+    const sortedItems = contentsTemplate.elements.filter((el) => checkTextType(el, "item"));
+    const sortedItemIds = sortedItems
+        .sort((a, b) => {
+        if (sortedItems.length > 6) {
+            const aItemNumber = sortedNumberItems.find((item) => item.groupId === a.groupId);
+            const bItemNumber = sortedNumberItems.find((item) => item.groupId === b.groupId);
+            if (aItemNumber && bItemNumber) {
+                return (sortedNumberItemIds.indexOf(aItemNumber.id) -
+                    sortedNumberItemIds.indexOf(bItemNumber.id));
+            }
+        }
+        const aIndex = a.left + a.top * 2;
+        const bIndex = b.left + b.top * 2;
+        return aIndex - bIndex;
+    })
+        .map((el) => el.id);
+    const longestText = outlineItem.data.items.reduce((longest, current) => (current.length > longest.length ? current : longest), "");
+    const unusedElIds = [];
+    const unusedGroupIds = [];
+    const elements = contentsTemplate.elements
+        .map((el) => {
+        if (el.type === "image" && el.imageType)
+            return getNewImgElement(el, imgs);
+        if (el.type !== "text" && el.type !== "shape")
+            return el;
+        if (checkTextType(el, "item")) {
+            const index = sortedItemIds.findIndex((id) => id === el.id);
+            const itemTitle = outlineItem.data.items[index];
+            if (itemTitle)
+                return getNewTextElement({
+                    el,
+                    text: itemTitle,
+                    maxLine: 1,
+                    longestText,
+                });
+            unusedElIds.push(el.id);
+            if (el.groupId)
+                unusedGroupIds.push(el.groupId);
+        }
+        if (checkTextType(el, "itemNumber")) {
+            const index = sortedNumberItemIds.findIndex((id) => id === el.id);
+            const offset = outlineItem.offset || 0;
+            return getNewTextElement({
+                el,
+                text: index + offset + 1 + "",
+                maxLine: 1,
+                digitPadding: true,
+            });
+        }
+        return el;
+    })
+        .filter((el) => !unusedElIds.includes(el.id) &&
+        !(el.groupId && unusedGroupIds.includes(el.groupId)));
+    return {
+        ...contentsTemplate,
+        id: `${contentsTemplate.id}-${nanoid(10)}`,
+        elements,
+    };
+};
+const generateTransition = (outlineItem, imgs, transitionTemplate, transitionIndex) => {
+    const elements = transitionTemplate.elements.map((el) => {
+        if (el.type === "image" && el.imageType)
+            return getNewImgElement(el, imgs);
+        if (el.type !== "text" && el.type !== "shape")
+            return el;
+        if (checkTextType(el, "title") && outlineItem.data.title) {
+            return getNewTextElement({
+                el,
+                text: outlineItem.data.title,
+                maxLine: 1,
+            });
+        }
+        if (checkTextType(el, "content") && outlineItem.data.text) {
+            return getNewTextElement({
+                el,
+                text: outlineItem.data.text,
+                maxLine: 3,
+            });
+        }
+        if (checkTextType(el, "partNumber")) {
+            return getNewTextElement({
+                el,
+                text: transitionIndex + "",
+                maxLine: 1,
+                digitPadding: true,
+            });
+        }
+        return el;
+    });
+    return {
+        ...transitionTemplate,
+        id: `${transitionTemplate.id}-${nanoid(10)}`,
+        elements,
+    };
+};
+const generateContent = (outlineItem, imgs, contentTemplates) => {
+    const _contentTemplates = getUseableTemplates(contentTemplates, outlineItem.data.items.length, "item");
+    const contentTemplate = _contentTemplates[Math.floor(Math.random() * _contentTemplates.length)];
+    const sortedTitleItemIds = contentTemplate.elements
+        .filter((el) => checkTextType(el, "itemTitle"))
+        .sort((a, b) => {
+        const aIndex = a.left + a.top * 2;
+        const bIndex = b.left + b.top * 2;
+        return aIndex - bIndex;
+    })
+        .map((el) => el.id);
+    const sortedTextItemIds = contentTemplate.elements
+        .filter((el) => checkTextType(el, "item"))
+        .sort((a, b) => {
+        const aIndex = a.left + a.top * 2;
+        const bIndex = b.left + b.top * 2;
+        return aIndex - bIndex;
+    })
+        .map((el) => el.id);
+    const sortedNumberItemIds = contentTemplate.elements
+        .filter((el) => checkTextType(el, "itemNumber"))
+        .sort((a, b) => {
+        const aIndex = a.left + a.top * 2;
+        const bIndex = b.left + b.top * 2;
+        return aIndex - bIndex;
+    })
+        .map((el) => el.id);
+    const itemTitles = [];
+    const itemTexts = [];
+    for (const _item of outlineItem.data.items) {
+        if (_item.title)
+            itemTitles.push(_item.title);
+        if (_item.text)
+            itemTexts.push(_item.text);
+    }
+    const longestTitle = itemTitles.reduce((longest, current) => (current.length > longest.length ? current : longest), "");
+    const longestText = itemTexts.reduce((longest, current) => (current.length > longest.length ? current : longest), "");
+    const elements = contentTemplate.elements.map((el) => {
+        if (el.type === "image" && el.imageType)
+            return getNewImgElement(el, imgs);
+        if (el.type !== "text" && el.type !== "shape")
+            return el;
+        if (outlineItem.data.items.length === 1) {
+            const contentItem = outlineItem.data.items[0];
+            if (checkTextType(el, "content") && contentItem.text) {
+                return getNewTextElement({
+                    el,
+                    text: contentItem.text,
+                    maxLine: 6,
+                });
+            }
+        }
+        else {
+            if (checkTextType(el, "itemTitle")) {
+                const index = sortedTitleItemIds.findIndex((id) => id === el.id);
+                const contentItem = outlineItem.data.items[index];
+                if (contentItem && contentItem.title) {
+                    return getNewTextElement({
+                        el,
+                        text: contentItem.title,
+                        longestText: longestTitle,
+                        maxLine: 1,
+                    });
+                }
+            }
+            if (checkTextType(el, "item")) {
+                const index = sortedTextItemIds.findIndex((id) => id === el.id);
+                const contentItem = outlineItem.data.items[index];
+                if (contentItem && contentItem.text) {
+                    return getNewTextElement({
+                        el,
+                        text: contentItem.text,
+                        longestText,
+                        maxLine: 4,
+                    });
+                }
+            }
+            if (checkTextType(el, "itemNumber")) {
+                const index = sortedNumberItemIds.findIndex((id) => id === el.id);
+                const offset = outlineItem.offset || 0;
+                return getNewTextElement({
+                    el,
+                    text: index + offset + 1 + "",
+                    maxLine: 1,
+                    digitPadding: true,
+                });
+            }
+        }
+        if (checkTextType(el, "title") && outlineItem.data.title) {
+            return getNewTextElement({
+                el,
+                text: outlineItem.data.title,
+                maxLine: 1,
+            });
+        }
+        return el;
+    });
+    return {
+        ...contentTemplate,
+        id: `${contentTemplate.id}-${nanoid(10)}`,
+        elements,
+    };
+};
+const generateEnd = (outlineItem, imgs, endTemplates) => {
+    const endTemplate = endTemplates[Math.floor(Math.random() * endTemplates.length)];
+    const elements = endTemplate.elements.map((el) => {
+        if (el.type === "image" && el.imageType)
+            return getNewImgElement(el, imgs);
+        return el;
+    });
+    return {
+        ...endTemplate,
+        id: `${endTemplate.id}-${nanoid(10)}`,
+        elements,
+    };
+};
+const getAdaptedFontsize = ({ text, fontSize, fontFamily, width, height, lineHeight, maxLine, }) => {
+    const canvas = new canvas_1.Canvas(width, height);
+    const context = canvas.getContext("2d");
+    let newFontSize = fontSize;
+    const minFontSize = 10;
+    while (newFontSize >= minFontSize) {
+        context.font = `${newFontSize}px ${fontFamily}`;
+        const textWidth = context.measureText(text).width;
+        const line = Math.ceil(textWidth / width);
+        if (maxLine > 1 && height) {
+            const heightOfLine = Math.max(newFontSize, 16) * (newFontSize < 15 ? 1.2 : lineHeight) * 1.2;
+            const totalHeight = line * heightOfLine;
+            if (totalHeight <= height)
+                return newFontSize;
+        }
+        if (line <= maxLine)
+            return newFontSize;
+        const step = newFontSize <= 22 ? 1 : 2;
+        newFontSize = newFontSize - step;
+    }
+    return minFontSize;
+};
+const getFontInfo = (htmlString) => {
+    const fontSizeRegex = /font-size:\s*(\d+(?:\.\d+)?)\s*px/i;
+    const fontFamilyRegex = /font-family:\s*['"]?([^'";]+)['"]?\s*(?=;|>|$)/i;
+    const defaultInfo = {
+        fontSize: 16,
+        fontFamily: "PingFang SC, Microsoft Yahei",
+    };
+    const fontSizeMatch = htmlString.match(fontSizeRegex);
+    const fontFamilyMatch = htmlString.match(fontFamilyRegex);
+    return {
+        fontSize: fontSizeMatch ? +fontSizeMatch[1].trim() : defaultInfo.fontSize,
+        fontFamily: fontFamilyMatch
+            ? fontFamilyMatch[1].trim()
+            : defaultInfo.fontFamily,
+    };
+};
+// 创建新图片元素函数
+const getNewImgElement = (el, imgs) => {
+    if (imgs.length === 0)
+        return el;
+    const randomImg = imgs[Math.floor(Math.random() * imgs.length)];
+    return {
+        ...el,
+        src: randomImg.src,
+        width: randomImg.width,
+        height: randomImg.height,
+    };
+};
+const checkTextType = (el, type) => {
+    return ((el.type === "text" && el.textType === type) ||
+        (el.type === "shape" && el.text && el.text.type === type));
+};
+const getUseableTemplates = (templates, n, type) => {
+    if (n === 1) {
+        const list = templates.filter((slide) => {
+            const items = slide.elements.filter((el) => checkTextType(el, type));
+            const titles = slide.elements.filter((el) => checkTextType(el, "title"));
+            const texts = slide.elements.filter((el) => checkTextType(el, "content"));
+            return !items.length && titles.length === 1 && texts.length === 1;
+        });
+        if (list.length)
+            return list;
+    }
+    let target = null;
+    const list = templates.filter((slide) => {
+        const len = slide.elements.filter((el) => checkTextType(el, type)).length;
+        return len >= n;
+    });
+    if (list.length === 0) {
+        const sorted = templates.sort((a, b) => {
+            const aLen = a.elements.filter((el) => checkTextType(el, type)).length;
+            const bLen = b.elements.filter((el) => checkTextType(el, type)).length;
+            return aLen - bLen;
+        });
+        target = sorted[sorted.length - 1];
+    }
+    else {
+        target = list.reduce((closest, current) => {
+            const currentLen = current.elements.filter((el) => checkTextType(el, type)).length;
+            const closestLen = closest.elements.filter((el) => checkTextType(el, type)).length;
+            return currentLen - n <= closestLen - n ? current : closest;
+        });
+    }
+    return templates.filter((slide) => {
+        const len = slide.elements.filter((el) => checkTextType(el, type)).length;
+        const targetLen = target.elements.filter((el) => checkTextType(el, type)).length;
+        return len === targetLen;
+    });
+};
+const getNewTextElement = ({ el, text, maxLine, longestText, digitPadding, }) => {
+    const padding = 10;
+    const width = el.width - padding * 2 - 2;
+    const height = el.height - padding * 2 - 2;
+    const lineHeight = el.type === "text" ? el.lineHeight || 1.5 : 1.2;
+    let content = el.type === "text" ? el.content : el.text.content;
+    const fontInfo = getFontInfo(content);
+    const size = getAdaptedFontsize({
+        text: longestText || text,
+        fontSize: fontInfo.fontSize,
+        fontFamily: fontInfo.fontFamily,
+        width,
+        height,
+        lineHeight,
+        maxLine,
+    });
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(content, "text/html");
+    const treeWalker = document.createTreeWalker(doc.body, NodeFilter.SHOW_TEXT);
+    const firstTextNode = treeWalker.nextNode();
+    if (firstTextNode) {
+        if (digitPadding &&
+            firstTextNode.textContent &&
+            firstTextNode.textContent.length === 2 &&
+            text.length === 1) {
+            firstTextNode.textContent = "0" + text;
+        }
+        else if (
+        // 处理 1. 1: 1：
+        digitPadding &&
+            firstTextNode.textContent &&
+            firstTextNode.textContent.length === 3 &&
+            [".", ":", "："].includes(firstTextNode.textContent.slice(-1)) &&
+            text.length === 1) {
+            firstTextNode.textContent =
+                "0" + text + firstTextNode.textContent.slice(-1);
+        }
+        else
+            firstTextNode.textContent = text;
+        let node;
+        while ((node = treeWalker.nextNode())) {
+            node.parentNode?.removeChild(node);
+        }
+    }
+    if (doc.body.innerHTML.indexOf("font-size") === -1) {
+        const p = doc.querySelector("p");
+        if (p)
+            p.style.fontSize = "16px";
+    }
+    content = doc.body.innerHTML.replace(/font-size:(.+?)px/g, `font-size: ${size}px`);
+    return el.type === "text"
+        ? { ...el, content, lineHeight: size < 15 ? 1.2 : el.lineHeight }
+        : { ...el, text: { ...el.text, content } };
+};

package/dist/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};