@8btc/ppt-generator-mcp 0.0.1

package/dist/types/slide.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/element.d.ts

@@ -0,0 +1,94 @@
+import type { PPTElement, PPTLineElement, Slide } from "../types/slide";
+interface RotatedElementData {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    rotate: number;
+}
+interface IdMap {
+    [id: string]: string;
+}
+/**
+ * 计算元素在画布中的矩形范围旋转后的新位置范围
+ * @param element 元素的位置大小和旋转角度信息
+ */
+export declare const getRectRotatedRange: (element: RotatedElementData) => {
+    xRange: number[];
+    yRange: number[];
+};
+/**
+ * 计算元素在画布中的矩形范围旋转后的新位置与旋转之前位置的偏离距离
+ * @param element 元素的位置大小和旋转角度信息
+ */
+export declare const getRectRotatedOffset: (element: RotatedElementData) => {
+    offsetX: number;
+    offsetY: number;
+};
+/**
+ * 计算元素在画布中的位置范围
+ * @param element 元素信息
+ */
+export declare const getElementRange: (element: PPTElement) => {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+/**
+ * 计算一组元素在画布中的位置范围
+ * @param elementList 一组元素信息
+ */
+export declare const getElementListRange: (elementList: PPTElement[]) => {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+/**
+ * 计算线条元素的长度
+ * @param element 线条元素
+ */
+export declare const getLineElementLength: (element: PPTLineElement) => number;
+export interface AlignLine {
+    value: number;
+    range: [number, number];
+}
+/**
+ * 将一组对齐吸附线进行去重：同位置的的多条对齐吸附线仅留下一条，取该位置所有对齐吸附线的最大值和最小值为新的范围
+ * @param lines 一组对齐吸附线信息
+ */
+export declare const uniqAlignLines: (lines: AlignLine[]) => AlignLine[];
+/**
+ * 以页面列表为基础，为每一个页面生成新的ID，并关联到旧ID形成一个字典
+ * 主要用于页面元素时，维持数据中各处页面ID原有的关系
+ * @param slides 页面列表
+ */
+export declare const createSlideIdMap: (slides: Slide[]) => IdMap;
+/**
+ * 以元素列表为基础，为每一个元素生成新的ID，并关联到旧ID形成一个字典
+ * 主要用于复制元素时，维持数据中各处元素ID原有的关系
+ * 例如：原本两个组合的元素拥有相同的groupId，复制后依然会拥有另一个相同的groupId
+ * @param elements 元素列表数据
+ */
+export declare const createElementIdMap: (elements: PPTElement[]) => {
+    groupIdMap: IdMap;
+    elIdMap: IdMap;
+};
+/**
+ * 根据表格的主题色，获取对应用于配色的子颜色
+ * @param themeColor 主题色
+ */
+export declare const getTableSubThemeColor: (themeColor: string) => string[];
+/**
+ * 获取线条元素路径字符串
+ * @param element 线条元素
+ */
+export declare const getLineElementPath: (element: PPTLineElement) => string;
+/**
+ * 判断一个元素是否在可视范围内
+ * @param element 元素
+ * @param parent 父元素
+ */
+export declare const isElementInViewport: (element: HTMLElement, parent: HTMLElement) => boolean;
+export {};

package/dist/utils/element.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isElementInViewport = exports.getLineElementPath = exports.getTableSubThemeColor = exports.createElementIdMap = exports.createSlideIdMap = exports.uniqAlignLines = exports.getLineElementLength = exports.getElementListRange = exports.getElementRange = exports.getRectRotatedOffset = exports.getRectRotatedRange = void 0;
+const tinycolor2_1 = __importDefault(require("tinycolor2"));
+const nanoid_1 = require("nanoid");
+/**
+ * 计算元素在画布中的矩形范围旋转后的新位置范围
+ * @param element 元素的位置大小和旋转角度信息
+ */
+const getRectRotatedRange = (element) => {
+    const { left, top, width, height, rotate = 0 } = element;
+    const radius = Math.sqrt(Math.pow(width, 2) + Math.pow(height, 2)) / 2;
+    const auxiliaryAngle = (Math.atan(height / width) * 180) / Math.PI;
+    const tlbraRadian = ((180 - rotate - auxiliaryAngle) * Math.PI) / 180;
+    const trblaRadian = ((auxiliaryAngle - rotate) * Math.PI) / 180;
+    const middleLeft = left + width / 2;
+    const middleTop = top + height / 2;
+    const xAxis = [
+        middleLeft + radius * Math.cos(tlbraRadian),
+        middleLeft + radius * Math.cos(trblaRadian),
+        middleLeft - radius * Math.cos(tlbraRadian),
+        middleLeft - radius * Math.cos(trblaRadian),
+    ];
+    const yAxis = [
+        middleTop - radius * Math.sin(tlbraRadian),
+        middleTop - radius * Math.sin(trblaRadian),
+        middleTop + radius * Math.sin(tlbraRadian),
+        middleTop + radius * Math.sin(trblaRadian),
+    ];
+    return {
+        xRange: [Math.min(...xAxis), Math.max(...xAxis)],
+        yRange: [Math.min(...yAxis), Math.max(...yAxis)],
+    };
+};
+exports.getRectRotatedRange = getRectRotatedRange;
+/**
+ * 计算元素在画布中的矩形范围旋转后的新位置与旋转之前位置的偏离距离
+ * @param element 元素的位置大小和旋转角度信息
+ */
+const getRectRotatedOffset = (element) => {
+    const { xRange: originXRange, yRange: originYRange } = (0, exports.getRectRotatedRange)({
+        left: element.left,
+        top: element.top,
+        width: element.width,
+        height: element.height,
+        rotate: 0,
+    });
+    const { xRange: rotatedXRange, yRange: rotatedYRange } = (0, exports.getRectRotatedRange)({
+        left: element.left,
+        top: element.top,
+        width: element.width,
+        height: element.height,
+        rotate: element.rotate,
+    });
+    return {
+        offsetX: rotatedXRange[0] - originXRange[0],
+        offsetY: rotatedYRange[0] - originYRange[0],
+    };
+};
+exports.getRectRotatedOffset = getRectRotatedOffset;
+/**
+ * 计算元素在画布中的位置范围
+ * @param element 元素信息
+ */
+const getElementRange = (element) => {
+    let minX, maxX, minY, maxY;
+    if (element.type === "line") {
+        minX = element.left;
+        maxX = element.left + Math.max(element.start[0], element.end[0]);
+        minY = element.top;
+        maxY = element.top + Math.max(element.start[1], element.end[1]);
+    }
+    else if ("rotate" in element && element.rotate) {
+        const { left, top, width, height, rotate } = element;
+        const { xRange, yRange } = (0, exports.getRectRotatedRange)({
+            left,
+            top,
+            width,
+            height,
+            rotate,
+        });
+        minX = xRange[0];
+        maxX = xRange[1];
+        minY = yRange[0];
+        maxY = yRange[1];
+    }
+    else {
+        minX = element.left;
+        maxX = element.left + element.width;
+        minY = element.top;
+        maxY = element.top + element.height;
+    }
+    return { minX, maxX, minY, maxY };
+};
+exports.getElementRange = getElementRange;
+/**
+ * 计算一组元素在画布中的位置范围
+ * @param elementList 一组元素信息
+ */
+const getElementListRange = (elementList) => {
+    const leftValues = [];
+    const topValues = [];
+    const rightValues = [];
+    const bottomValues = [];
+    elementList.forEach((element) => {
+        const { minX, maxX, minY, maxY } = (0, exports.getElementRange)(element);
+        leftValues.push(minX);
+        topValues.push(minY);
+        rightValues.push(maxX);
+        bottomValues.push(maxY);
+    });
+    const minX = Math.min(...leftValues);
+    const maxX = Math.max(...rightValues);
+    const minY = Math.min(...topValues);
+    const maxY = Math.max(...bottomValues);
+    return { minX, maxX, minY, maxY };
+};
+exports.getElementListRange = getElementListRange;
+/**
+ * 计算线条元素的长度
+ * @param element 线条元素
+ */
+const getLineElementLength = (element) => {
+    const deltaX = element.end[0] - element.start[0];
+    const deltaY = element.end[1] - element.start[1];
+    const len = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    return len;
+};
+exports.getLineElementLength = getLineElementLength;
+/**
+ * 将一组对齐吸附线进行去重：同位置的的多条对齐吸附线仅留下一条，取该位置所有对齐吸附线的最大值和最小值为新的范围
+ * @param lines 一组对齐吸附线信息
+ */
+const uniqAlignLines = (lines) => {
+    const uniqLines = [];
+    lines.forEach((line) => {
+        const index = uniqLines.findIndex((_line) => _line.value === line.value);
+        if (index === -1)
+            uniqLines.push(line);
+        else {
+            const uniqLine = uniqLines[index];
+            const rangeMin = Math.min(uniqLine.range[0], line.range[0]);
+            const rangeMax = Math.max(uniqLine.range[1], line.range[1]);
+            const range = [rangeMin, rangeMax];
+            const _line = { value: line.value, range };
+            uniqLines[index] = _line;
+        }
+    });
+    return uniqLines;
+};
+exports.uniqAlignLines = uniqAlignLines;
+/**
+ * 以页面列表为基础，为每一个页面生成新的ID，并关联到旧ID形成一个字典
+ * 主要用于页面元素时，维持数据中各处页面ID原有的关系
+ * @param slides 页面列表
+ */
+const createSlideIdMap = (slides) => {
+    const slideIdMap = {};
+    for (const slide of slides) {
+        slideIdMap[slide.id] = (0, nanoid_1.nanoid)(10);
+    }
+    return slideIdMap;
+};
+exports.createSlideIdMap = createSlideIdMap;
+/**
+ * 以元素列表为基础，为每一个元素生成新的ID，并关联到旧ID形成一个字典
+ * 主要用于复制元素时，维持数据中各处元素ID原有的关系
+ * 例如：原本两个组合的元素拥有相同的groupId，复制后依然会拥有另一个相同的groupId
+ * @param elements 元素列表数据
+ */
+const createElementIdMap = (elements) => {
+    const groupIdMap = {};
+    const elIdMap = {};
+    for (const element of elements) {
+        const groupId = element.groupId;
+        if (groupId && !groupIdMap[groupId]) {
+            groupIdMap[groupId] = (0, nanoid_1.nanoid)(10);
+        }
+        elIdMap[element.id] = (0, nanoid_1.nanoid)(10);
+    }
+    return {
+        groupIdMap,
+        elIdMap,
+    };
+};
+exports.createElementIdMap = createElementIdMap;
+/**
+ * 根据表格的主题色，获取对应用于配色的子颜色
+ * @param themeColor 主题色
+ */
+const getTableSubThemeColor = (themeColor) => {
+    const rgba = (0, tinycolor2_1.default)(themeColor);
+    return [rgba.setAlpha(0.3).toRgbString(), rgba.setAlpha(0.1).toRgbString()];
+};
+exports.getTableSubThemeColor = getTableSubThemeColor;
+/**
+ * 获取线条元素路径字符串
+ * @param element 线条元素
+ */
+const getLineElementPath = (element) => {
+    const start = element.start.join(",");
+    const end = element.end.join(",");
+    if (element.broken) {
+        const mid = element.broken.join(",");
+        return `M${start} L${mid} L${end}`;
+    }
+    else if (element.broken2) {
+        const { minX, maxX, minY, maxY } = (0, exports.getElementRange)(element);
+        if (maxX - minX >= maxY - minY)
+            return `M${start} L${element.broken2[0]},${element.start[1]} L${element.broken2[0]},${element.end[1]} ${end}`;
+        return `M${start} L${element.start[0]},${element.broken2[1]} L${element.end[0]},${element.broken2[1]} ${end}`;
+    }
+    else if (element.curve) {
+        const mid = element.curve.join(",");
+        return `M${start} Q${mid} ${end}`;
+    }
+    else if (element.cubic) {
+        const [c1, c2] = element.cubic;
+        const p1 = c1.join(",");
+        const p2 = c2.join(",");
+        return `M${start} C${p1} ${p2} ${end}`;
+    }
+    return `M${start} L${end}`;
+};
+exports.getLineElementPath = getLineElementPath;
+/**
+ * 判断一个元素是否在可视范围内
+ * @param element 元素
+ * @param parent 父元素
+ */
+const isElementInViewport = (element, parent) => {
+    const elementRect = element.getBoundingClientRect();
+    const parentRect = parent.getBoundingClientRect();
+    return (elementRect.top >= parentRect.top && elementRect.bottom <= parentRect.bottom);
+};
+exports.isElementInViewport = isElementInViewport;

package/dist/utils/htmlParser/format.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLNode, AST } from "./types";
+export declare const splitHead: (str: string, sep: string) => string[];
+export declare const format: (nodes: HTMLNode[]) => AST[];

package/dist/utils/htmlParser/format.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = exports.splitHead = void 0;
+const splitHead = (str, sep) => {
+    const idx = str.indexOf(sep);
+    if (idx === -1)
+        return [str];
+    return [str.slice(0, idx), str.slice(idx + sep.length)];
+};
+exports.splitHead = splitHead;
+const unquote = (str) => {
+    const car = str.charAt(0);
+    const end = str.length - 1;
+    const isQuoteStart = car === '"' || car === "'";
+    if (isQuoteStart && car === str.charAt(end)) {
+        return str.slice(1, end);
+    }
+    return str;
+};
+const formatAttributes = (attributes) => {
+    return attributes.map((attribute) => {
+        const parts = (0, exports.splitHead)(attribute.trim(), "=");
+        const key = parts[0];
+        const value = typeof parts[1] === "string" ? unquote(parts[1]) : null;
+        return { key, value };
+    });
+};
+const format = (nodes) => {
+    return nodes.map((node) => {
+        if (node.type === "element") {
+            const children = (0, exports.format)(node.children);
+            const item = {
+                type: "element",
+                tagName: node.tagName.toLowerCase(),
+                attributes: formatAttributes(node.attributes),
+                children,
+            };
+            return item;
+        }
+        const item = {
+            type: node.type,
+            content: node.content,
+        };
+        return item;
+    });
+};
+exports.format = format;

package/dist/utils/htmlParser/index.d.ts

@@ -0,0 +1,4 @@
+import { toHTML } from "./stringify";
+export type { AST } from "./types";
+export declare const toAST: (str: string) => import("./types").AST[];
+export { toHTML };

package/dist/utils/htmlParser/index.js

@@ -0,0 +1,15 @@
+"use strict";
+// 参考：https://github.com/andrejewski/himalaya 用TypeScript重写并简化部分功能
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHTML = exports.toAST = void 0;
+const lexer_1 = require("./lexer");
+const parser_1 = require("./parser");
+const format_1 = require("./format");
+const stringify_1 = require("./stringify");
+Object.defineProperty(exports, "toHTML", { enumerable: true, get: function () { return stringify_1.toHTML; } });
+const toAST = (str) => {
+    const tokens = (0, lexer_1.lexer)(str);
+    const nodes = (0, parser_1.parser)(tokens);
+    return (0, format_1.format)(nodes);
+};
+exports.toAST = toAST;

package/dist/utils/htmlParser/lexer.d.ts

@@ -0,0 +1,2 @@
+import type { Token } from "./types";
+export declare const lexer: (str: string) => Token[];

package/dist/utils/htmlParser/lexer.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lexer = void 0;
+const lodash_1 = require("lodash");
+const tags_1 = require("./tags");
+const jumpPosition = (state, end) => {
+    const len = end - state.position;
+    movePositopn(state, len);
+};
+const movePositopn = (state, len) => {
+    state.position = state.position + len;
+};
+const findTextEnd = (str, index) => {
+    const isEnd = false;
+    while (!isEnd) {
+        const textEnd = str.indexOf("<", index);
+        if (textEnd === -1) {
+            return textEnd;
+        }
+        const char = str.charAt(textEnd + 1);
+        if (char === "/" || char === "!" || /[A-Za-z0-9]/.test(char)) {
+            return textEnd;
+        }
+        index = textEnd + 1;
+    }
+    return -1;
+};
+const lexText = (state) => {
+    const { str } = state;
+    let textEnd = findTextEnd(str, state.position);
+    if (textEnd === state.position)
+        return;
+    if (textEnd === -1) {
+        textEnd = str.length;
+    }
+    const content = str.slice(state.position, textEnd);
+    jumpPosition(state, textEnd);
+    state.tokens.push({
+        type: "text",
+        content,
+    });
+};
+const lexComment = (state) => {
+    const { str } = state;
+    movePositopn(state, 4);
+    let contentEnd = str.indexOf("-->", state.position);
+    let commentEnd = contentEnd + 3;
+    if (contentEnd === -1) {
+        contentEnd = commentEnd = str.length;
+    }
+    const content = str.slice(state.position, contentEnd);
+    jumpPosition(state, commentEnd);
+    state.tokens.push({
+        type: "comment",
+        content,
+    });
+};
+const lexTagName = (state) => {
+    const { str } = state;
+    const len = str.length;
+    let start = state.position;
+    while (start < len) {
+        const char = str.charAt(start);
+        const isTagChar = !(/\s/.test(char) || char === "/" || char === ">");
+        if (isTagChar)
+            break;
+        start++;
+    }
+    let end = start + 1;
+    while (end < len) {
+        const char = str.charAt(end);
+        const isTagChar = !(/\s/.test(char) || char === "/" || char === ">");
+        if (!isTagChar)
+            break;
+        end++;
+    }
+    jumpPosition(state, end);
+    const tagName = str.slice(start, end);
+    state.tokens.push({
+        type: "tag",
+        content: tagName,
+    });
+    return tagName;
+};
+const lexTagAttributes = (state) => {
+    const { str, tokens } = state;
+    let cursor = state.position;
+    let quote = null;
+    let wordBegin = cursor;
+    const words = [];
+    const len = str.length;
+    while (cursor < len) {
+        const char = str.charAt(cursor);
+        if (quote) {
+            const isQuoteEnd = char === quote;
+            if (isQuoteEnd)
+                quote = null;
+            cursor++;
+            continue;
+        }
+        const isTagEnd = char === "/" || char === ">";
+        if (isTagEnd) {
+            if (cursor !== wordBegin)
+                words.push(str.slice(wordBegin, cursor));
+            break;
+        }
+        const isWordEnd = /\s/.test(char);
+        if (isWordEnd) {
+            if (cursor !== wordBegin)
+                words.push(str.slice(wordBegin, cursor));
+            wordBegin = cursor + 1;
+            cursor++;
+            continue;
+        }
+        const isQuoteStart = char === "'" || char === '"';
+        if (isQuoteStart) {
+            quote = char;
+            cursor++;
+            continue;
+        }
+        cursor++;
+    }
+    jumpPosition(state, cursor);
+    const type = "attribute";
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        const isNotPair = word.indexOf("=") === -1;
+        if (isNotPair) {
+            const secondWord = words[i + 1];
+            if (secondWord && (0, lodash_1.startsWith)(secondWord, "=")) {
+                if (secondWord.length > 1) {
+                    const newWord = word + secondWord;
+                    tokens.push({ type, content: newWord });
+                    i += 1;
+                    continue;
+                }
+                const thirdWord = words[i + 2];
+                i += 1;
+                if (thirdWord) {
+                    const newWord = word + "=" + thirdWord;
+                    tokens.push({ type, content: newWord });
+                    i += 1;
+                    continue;
+                }
+            }
+        }
+        if ((0, lodash_1.endsWith)(word, "=")) {
+            const secondWord = words[i + 1];
+            if (secondWord && secondWord.indexOf("=") === -1) {
+                const newWord = word + secondWord;
+                tokens.push({ type, content: newWord });
+                i += 1;
+                continue;
+            }
+            const newWord = word.slice(0, -1);
+            tokens.push({ type, content: newWord });
+            continue;
+        }
+        tokens.push({ type, content: word });
+    }
+};
+const lexSkipTag = (tagName, state) => {
+    const { str, tokens } = state;
+    const safeTagName = tagName.toLowerCase();
+    const len = str.length;
+    let index = state.position;
+    while (index < len) {
+        const nextTag = str.indexOf("</", index);
+        if (nextTag === -1) {
+            lexText(state);
+            break;
+        }
+        const tagState = {
+            str,
+            position: state.position,
+            tokens: [],
+        };
+        jumpPosition(tagState, nextTag);
+        const name = lexTag(tagState);
+        if (safeTagName !== name.toLowerCase()) {
+            index = tagState.position;
+            continue;
+        }
+        if (nextTag !== state.position) {
+            const textStart = state.position;
+            jumpPosition(state, nextTag);
+            tokens.push({
+                type: "text",
+                content: str.slice(textStart, nextTag),
+            });
+        }
+        tokens.push(...tagState.tokens);
+        jumpPosition(state, tagState.position);
+        break;
+    }
+};
+const lexTag = (state) => {
+    const { str } = state;
+    const secondChar = str.charAt(state.position + 1);
+    const tagStartClose = secondChar === "/";
+    movePositopn(state, tagStartClose ? 2 : 1);
+    state.tokens.push({
+        type: "tag-start",
+        close: tagStartClose,
+    });
+    const tagName = lexTagName(state);
+    lexTagAttributes(state);
+    const firstChar = str.charAt(state.position);
+    const tagEndClose = firstChar === "/";
+    movePositopn(state, tagEndClose ? 2 : 1);
+    state.tokens.push({
+        type: "tag-end",
+        close: tagEndClose,
+    });
+    return tagName;
+};
+const lex = (state) => {
+    const str = state.str;
+    const len = str.length;
+    while (state.position < len) {
+        const start = state.position;
+        lexText(state);
+        if (state.position === start) {
+            const isComment = (0, lodash_1.startsWith)(str, "!--", start + 1);
+            if (isComment)
+                lexComment(state);
+            else {
+                const tagName = lexTag(state);
+                const safeTag = tagName.toLowerCase();
+                if (tags_1.childlessTags.includes(safeTag))
+                    lexSkipTag(tagName, state);
+            }
+        }
+    }
+};
+const lexer = (str) => {
+    const state = {
+        str,
+        position: 0,
+        tokens: [],
+    };
+    lex(state);
+    return state.tokens;
+};
+exports.lexer = lexer;

package/dist/utils/htmlParser/parser.d.ts

@@ -0,0 +1,15 @@
+import type { Token, HTMLNode } from "./types";
+interface StackItem {
+    tagName: string | null;
+    children: HTMLNode[];
+}
+interface State {
+    stack: StackItem[];
+    cursor: number;
+    tokens: Token[];
+}
+export declare const parser: (tokens: Token[]) => HTMLNode[];
+export declare const hasTerminalParent: (tagName: string, stack: StackItem[]) => boolean;
+export declare const rewindStack: (stack: StackItem[], newLength: number) => void;
+export declare const parse: (state: State) => void;
+export {};