@xw-components/formula-editor 18.1.0

package/esm2022/formula-editor.service.mjs

@@ -0,0 +1,318 @@
+import { inject, Injectable } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { Node, mergeAttributes } from '@tiptap/core';
+import * as i0 from "@angular/core";
+export class FormulaEditorService {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+    }
+    initNodes() {
+        this.createFuncNode();
+        this.createFieldNode();
+    }
+    createFieldNode() {
+        this.fieldNode = Node.create({
+            name: 'field',
+            inline: true,
+            group: 'inline',
+            selectable: false,
+            draggable: true,
+            atom: true,
+            addAttributes() {
+                return {
+                    id: {
+                        default: null
+                    },
+                    name: {
+                        default: ''
+                    },
+                    className: {
+                        default: ''
+                    },
+                    dataType: {
+                        default: 'field'
+                    }
+                };
+            },
+            renderText({ node }) {
+                return `${node.attrs['name']}`;
+            },
+            parseHTML() {
+                return [{ tag: 'div[data-type="field"]' }];
+            },
+            renderHTML({ HTMLAttributes, node }) {
+                return [
+                    'div',
+                    mergeAttributes({
+                        'data-type': 'field',
+                        class: `field-node ${node.attrs['className']}` || '',
+                        contenteditable: 'false',
+                        style: `display: inline-block;margin: 0 4px;font-size: 13px;height: 18px;line-height: 18px;`
+                    }, HTMLAttributes),
+                    node.attrs['name']
+                ];
+            }
+        });
+    }
+    createFuncNode() {
+        this.funcNode = Node.create({
+            name: 'func',
+            inline: true,
+            group: 'inline',
+            selectable: false,
+            draggable: false,
+            content: 'inline*',
+            atom: true,
+            addAttributes() {
+                return {
+                    id: {
+                        default: null
+                    },
+                    name: {
+                        default: ''
+                    },
+                    className: {
+                        default: ''
+                    },
+                    dataType: {
+                        default: 'func'
+                    }
+                };
+            },
+            renderText({ node }) {
+                const funcName = node.attrs['name'] || '';
+                const childrenText = node.content.content
+                    .map(child => {
+                    if (child.text) {
+                        return child.text;
+                    }
+                    if (child.type && child.type.spec && child.type.spec['toText']) {
+                        return child.type.spec['toText']({ node: child });
+                    }
+                    return '';
+                })
+                    .join('');
+                return `${funcName}(${childrenText})`;
+            },
+            parseHTML() {
+                return [{ tag: 'div[data-type="func"]' }];
+            },
+            addNodeView() {
+                return ({ node }) => {
+                    const createElement = (tag, props = {}) => {
+                        const element = document.createElement(tag);
+                        Object.entries(props).forEach(([key, value]) => {
+                            if (key === 'style') {
+                                Object.entries(value).forEach(([styleKey, styleValue]) => {
+                                    element.style[styleKey] = styleValue;
+                                });
+                            }
+                            else if (key === 'innerText') {
+                                element.innerText = value;
+                            }
+                            else if (key === 'className') {
+                                element.className = value;
+                            }
+                            else {
+                                element.setAttribute(key, value);
+                            }
+                        });
+                        return element;
+                    };
+                    const className = node.attrs['className'] || '';
+                    const funcName = node.attrs['name'];
+                    const container = createElement('span', {
+                        style: {
+                            display: 'inline-block',
+                            margin: '0 4px',
+                            fontSize: '13px'
+                        }
+                    });
+                    const content = createElement('span', {
+                        style: {
+                            whiteSpace: 'pre-wrap',
+                            display: 'inline-block'
+                        },
+                        contenteditable: 'true'
+                    });
+                    const before = createElement('span', {
+                        innerText: `${funcName} `,
+                        contenteditable: 'false',
+                        className
+                    });
+                    const bracket = (value, style = {}) => {
+                        return createElement('span', {
+                            innerText: value,
+                            contenteditable: 'false',
+                            style: {
+                                ...style
+                            }
+                        });
+                    };
+                    container.append(before, bracket('(', { marginRight: '2px' }), content, bracket(')', { marginLeft: '2px' }));
+                    return {
+                        dom: container,
+                        contentDOM: content
+                    };
+                };
+            }
+        });
+    }
+    /**
+     * 校验公式的JSON表示是否有效
+     * @param formula 公式的JSON表示
+     * @returns 校验结果，包含是否有效和错误信息数组
+     */
+    validateFormula(formula) {
+        const errors = [];
+        if (!formula) {
+            errors.push('公式不能为空');
+            return { isValid: false, errors };
+        }
+        if (formula.type !== 'doc') {
+            errors.push('公式根节点类型必须是 doc');
+        }
+        if (!formula.content || !Array.isArray(formula.content)) {
+            errors.push('公式必须包含 content 数组');
+            return { isValid: false, errors };
+        }
+        for (const paragraph of formula.content) {
+            if (paragraph.type !== 'paragraph') {
+                errors.push('段落类型必须是 paragraph');
+                continue;
+            }
+            if (!paragraph.content || !Array.isArray(paragraph.content)) {
+                continue;
+            }
+            for (const node of paragraph.content) {
+                this.validateNode(node, errors);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * 从JSON数据中提取内容文本或HTML
+     * @param jsonData 公式的JSON表示
+     * @param outputFormat 输出格式，'text'或'html'，默认'text'
+     * @returns 提取的内容文本或HTML字符串
+     */
+    getContentFromJson(jsonData, outputFormat = 'text') {
+        if (!jsonData || !jsonData.content)
+            return '';
+        return outputFormat === 'html'
+            ? this.sanitizer.bypassSecurityTrustHtml(this.processContentToHtml(jsonData.content))
+            : this.processContent(jsonData.content);
+    }
+    processContent(content) {
+        if (!content || !Array.isArray(content))
+            return '';
+        return content.map(item => this.processNode(item)).join('');
+    }
+    processNode(node) {
+        if (!node)
+            return '';
+        switch (node.type) {
+            case 'func':
+                return this.processFuncNode(node);
+            case 'field':
+                return `{${node.attrs?.name || ''}}`;
+            case 'metric':
+                return `[${node.attrs?.name || ''}]`;
+            case 'text':
+                return node.text || '';
+            case 'paragraph':
+                return this.processContent(node.content);
+            case 'doc':
+                return this.processContent(node.content);
+            default:
+                return '';
+        }
+    }
+    processFuncNode(node) {
+        const funcName = node.attrs?.name || '';
+        const content = this.processContent(node.content);
+        return `${funcName}(${content})`;
+    }
+    processContentToHtml(content) {
+        if (!content || !Array.isArray(content))
+            return '';
+        return content.map(item => this.processNodeToHtml(item)).join('');
+    }
+    processNodeToHtml(node) {
+        if (!node)
+            return '';
+        switch (node.type) {
+            case 'func':
+                return this.processFuncNodeToHtml(node);
+            case 'field':
+                return `<span class="${node.attrs?.className || ''}" style="display: inline-block; margin: 0 4px;height: 18px;line-height: 18px;">${node.attrs?.name || ''}</span>`;
+            case 'text':
+                return this.escapeHtml(node.text || '');
+            case 'paragraph':
+                return this.processContentToHtml(node.content);
+            case 'doc':
+                return this.processContentToHtml(node.content);
+            default:
+                return '';
+        }
+    }
+    processFuncNodeToHtml(node) {
+        const funcName = node.attrs?.name || '';
+        const className = node.attrs?.className || '';
+        const content = this.processContentToHtml(node.content);
+        return `<span style="display: inline-block; margin: 0 4px;"><span contenteditable="false" class="${className}">${funcName}(</span><span style="white-space: pre-wrap; display: inline-block; margin: 0 4px;" contenteditable="true">${content}</span><span contenteditable="false" class="${className}">)</span></span>`;
+    }
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+    validateNode(node, errors, path = '') {
+        if (!node || !node.type) {
+            return;
+        }
+        const currentPath = path ? `${path} > ${node.type}` : node.type;
+        if (node.type === 'func') {
+            this.validateFuncNode(node, errors, currentPath);
+        }
+    }
+    validateFuncNode(node, errors, path) {
+        if (!node.content || !Array.isArray(node.content)) {
+            return;
+        }
+        const content = node.content;
+        const length = content.length;
+        for (let i = 0; i < length; i++) {
+            const currentItem = content[i];
+            const nextItem = content[i + 1];
+            if (currentItem.type === 'field' || currentItem.type === 'func') {
+                if (i < length - 1) {
+                    if (nextItem && nextItem.type === 'text') {
+                        const text = nextItem.text || '';
+                        if (!text.startsWith(',')) {
+                            errors.push(`${path}: 参数之间必须用逗号分隔，位置 ${i + 1}`);
+                        }
+                    }
+                    else {
+                        errors.push(`${path}: 参数之间必须用逗号分隔，位置 ${i + 1}`);
+                    }
+                }
+            }
+            if (currentItem.type === 'func') {
+                this.validateFuncNode(currentItem, errors, `${path} > ${currentItem.attrs?.name || 'func'}`);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FormulaEditorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FormulaEditorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FormulaEditorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formula-editor.service.js","sourceRoot":"","sources":["../../../../components/formula-editor/formula-editor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { style } from '@angular/animations';\nimport { inject, Injectable } from '@angular/core';\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\nimport { Editor, Node, mergeAttributes } from '@tiptap/core';\nimport { NzSafeAny } from 'ng-zorro-antd/core/types';\nexport interface ValidationResult {\n  isValid: boolean;\n  errors: string[];\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FormulaEditorService {\n  private readonly sanitizer: DomSanitizer = inject(DomSanitizer);\n  funcNode?: Node;\n  fieldNode?: Node;\n  paramNode?: Node;\n\n  initNodes() {\n    this.createFuncNode();\n    this.createFieldNode();\n  }\n\n  createFieldNode() {\n    this.fieldNode = Node.create({\n      name: 'field',\n      inline: true,\n      group: 'inline',\n      selectable: false,\n      draggable: true,\n      atom: true,\n      addAttributes() {\n        return {\n          id: {\n            default: null\n          },\n          name: {\n            default: ''\n          },\n          className: {\n            default: ''\n          },\n          dataType: {\n            default: 'field'\n          }\n        };\n      },\n      renderText({ node }) {\n        return `${node.attrs['name']}`;\n      },\n      parseHTML() {\n        return [{ tag: 'div[data-type=\"field\"]' }];\n      },\n      renderHTML({ HTMLAttributes, node }) {\n        return [\n          'div',\n          mergeAttributes(\n            {\n              'data-type': 'field',\n              class: `field-node ${node.attrs['className']}` || '',\n              contenteditable: 'false',\n              style: `display: inline-block;margin: 0 4px;font-size: 13px;height: 18px;line-height: 18px;`\n            },\n            HTMLAttributes\n          ),\n          node.attrs['name']\n        ];\n      }\n    });\n  }\n\n  createFuncNode() {\n    this.funcNode = Node.create({\n      name: 'func',\n      inline: true,\n      group: 'inline',\n      selectable: false,\n      draggable: false,\n      content: 'inline*',\n      atom: true,\n      addAttributes() {\n        return {\n          id: {\n            default: null\n          },\n          name: {\n            default: ''\n          },\n          className: {\n            default: ''\n          },\n          dataType: {\n            default: 'func'\n          }\n        };\n      },\n      renderText({ node }) {\n        const funcName = node.attrs['name'] || '';\n        const childrenText = node.content.content\n          .map(child => {\n            if (child.text) {\n              return child.text;\n            }\n            if (child.type && child.type.spec && child.type.spec['toText']) {\n              return child.type.spec['toText']({ node: child });\n            }\n            return '';\n          })\n          .join('');\n        return `${funcName}(${childrenText})`;\n      },\n      parseHTML() {\n        return [{ tag: 'div[data-type=\"func\"]' }];\n      },\n      addNodeView() {\n        return ({ node }) => {\n          const createElement = (tag: string, props: Record<string, any> = {}) => {\n            const element = document.createElement(tag);\n            Object.entries(props).forEach(([key, value]) => {\n              if (key === 'style') {\n                Object.entries(value).forEach(([styleKey, styleValue]) => {\n                  (element.style as any)[styleKey] = styleValue;\n                });\n              } else if (key === 'innerText') {\n                element.innerText = value;\n              } else if (key === 'className') {\n                element.className = value;\n              } else {\n                element.setAttribute(key, value);\n              }\n            });\n            return element;\n          };\n\n          const className = node.attrs['className'] || '';\n          const funcName = node.attrs['name'];\n\n          const container = createElement('span', {\n            style: {\n              display: 'inline-block',\n              margin: '0 4px',\n              fontSize: '13px'\n            }\n          });\n\n          const content = createElement('span', {\n            style: {\n              whiteSpace: 'pre-wrap',\n              display: 'inline-block'\n            },\n            contenteditable: 'true'\n          });\n\n          const before = createElement('span', {\n            innerText: `${funcName} `,\n            contenteditable: 'false',\n            className\n          });\n\n          const bracket = (value: string, style: Record<string, any> = {}) => {\n            return createElement('span', {\n              innerText: value,\n              contenteditable: 'false',\n              style: {\n                ...style\n              }\n            });\n          };\n\n          container.append(before, bracket('(', { marginRight: '2px' }), content, bracket(')', { marginLeft: '2px' }));\n\n          return {\n            dom: container,\n            contentDOM: content\n          };\n        };\n      }\n    });\n  }\n\n  /**\n   * 校验公式的JSON表示是否有效\n   * @param formula 公式的JSON表示\n   * @returns 校验结果，包含是否有效和错误信息数组\n   */\n  public validateFormula(formula: any): ValidationResult {\n    const errors: string[] = [];\n\n    if (!formula) {\n      errors.push('公式不能为空');\n      return { isValid: false, errors };\n    }\n\n    if (formula.type !== 'doc') {\n      errors.push('公式根节点类型必须是 doc');\n    }\n\n    if (!formula.content || !Array.isArray(formula.content)) {\n      errors.push('公式必须包含 content 数组');\n      return { isValid: false, errors };\n    }\n\n    for (const paragraph of formula.content) {\n      if (paragraph.type !== 'paragraph') {\n        errors.push('段落类型必须是 paragraph');\n        continue;\n      }\n\n      if (!paragraph.content || !Array.isArray(paragraph.content)) {\n        continue;\n      }\n\n      for (const node of paragraph.content) {\n        this.validateNode(node, errors);\n      }\n    }\n\n    return {\n      isValid: errors.length === 0,\n      errors\n    };\n  }\n\n  /**\n   * 从JSON数据中提取内容文本或HTML\n   * @param jsonData 公式的JSON表示\n   * @param outputFormat 输出格式，'text'或'html'，默认'text'\n   * @returns 提取的内容文本或HTML字符串\n   */\n  public getContentFromJson(jsonData: NzSafeAny, outputFormat: 'text' | 'html' = 'text'): string | SafeHtml {\n    if (!jsonData || !jsonData.content) return '';\n    return outputFormat === 'html'\n      ? this.sanitizer.bypassSecurityTrustHtml(this.processContentToHtml(jsonData.content))\n      : this.processContent(jsonData.content);\n  }\n\n  private processContent(content: any[]): string {\n    if (!content || !Array.isArray(content)) return '';\n    return content.map(item => this.processNode(item)).join('');\n  }\n\n  private processNode(node: any): string {\n    if (!node) return '';\n\n    switch (node.type) {\n      case 'func':\n        return this.processFuncNode(node);\n      case 'field':\n        return `{${node.attrs?.name || ''}}`;\n      case 'metric':\n        return `[${node.attrs?.name || ''}]`;\n      case 'text':\n        return node.text || '';\n      case 'paragraph':\n        return this.processContent(node.content);\n      case 'doc':\n        return this.processContent(node.content);\n      default:\n        return '';\n    }\n  }\n\n  private processFuncNode(node: any): string {\n    const funcName = node.attrs?.name || '';\n    const content = this.processContent(node.content);\n    return `${funcName}(${content})`;\n  }\n\n  private processContentToHtml(content: any[]): string {\n    if (!content || !Array.isArray(content)) return '';\n\n    return content.map(item => this.processNodeToHtml(item)).join('');\n  }\n\n  private processNodeToHtml(node: any): string {\n    if (!node) return '';\n\n    switch (node.type) {\n      case 'func':\n        return this.processFuncNodeToHtml(node);\n      case 'field':\n        return `<span class=\"${node.attrs?.className || ''}\" style=\"display: inline-block; margin: 0 4px;height: 18px;line-height: 18px;\">${node.attrs?.name || ''}</span>`;\n      case 'text':\n        return this.escapeHtml(node.text || '');\n      case 'paragraph':\n        return this.processContentToHtml(node.content);\n      case 'doc':\n        return this.processContentToHtml(node.content);\n      default:\n        return '';\n    }\n  }\n\n  private processFuncNodeToHtml(node: any): string {\n    const funcName = node.attrs?.name || '';\n    const className = node.attrs?.className || '';\n    const content = this.processContentToHtml(node.content);\n\n    return `<span style=\"display: inline-block; margin: 0 4px;\"><span contenteditable=\"false\" class=\"${className}\">${funcName}(</span><span style=\"white-space: pre-wrap; display: inline-block; margin: 0 4px;\" contenteditable=\"true\">${content}</span><span contenteditable=\"false\" class=\"${className}\">)</span></span>`;\n  }\n\n  private escapeHtml(text: string): string {\n    const div = document.createElement('div');\n    div.textContent = text;\n    return div.innerHTML;\n  }\n\n  private validateNode(node: any, errors: string[], path: string = ''): void {\n    if (!node || !node.type) {\n      return;\n    }\n\n    const currentPath = path ? `${path} > ${node.type}` : node.type;\n\n    if (node.type === 'func') {\n      this.validateFuncNode(node, errors, currentPath);\n    }\n  }\n\n  private validateFuncNode(node: any, errors: string[], path: string): void {\n    if (!node.content || !Array.isArray(node.content)) {\n      return;\n    }\n\n    const content = node.content;\n    const length = content.length;\n\n    for (let i = 0; i < length; i++) {\n      const currentItem = content[i];\n      const nextItem = content[i + 1];\n\n      if (currentItem.type === 'field' || currentItem.type === 'func') {\n        if (i < length - 1) {\n          if (nextItem && nextItem.type === 'text') {\n            const text = nextItem.text || '';\n            if (!text.startsWith(',')) {\n              errors.push(`${path}: 参数之间必须用逗号分隔，位置 ${i + 1}`);\n            }\n          } else {\n            errors.push(`${path}: 参数之间必须用逗号分隔，位置 ${i + 1}`);\n          }\n        }\n      }\n\n      if (currentItem.type === 'func') {\n        this.validateFuncNode(currentItem, errors, `${path} > ${currentItem.attrs?.name || 'func'}`);\n      }\n    }\n  }\n}\n"]}

package/esm2022/index.mjs

@@ -0,0 +1,6 @@
+export * from './formula-editor.component';
+export * from './formula-editor.model';
+export * from './formula-editor-request.service';
+export * from './formula-editor.service';
+export * from './formula-editor-icon';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jb21wb25lbnRzL2Zvcm11bGEtZWRpdG9yL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZm9ybXVsYS1lZGl0b3IuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybXVsYS1lZGl0b3IubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtdWxhLWVkaXRvci1yZXF1ZXN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtdWxhLWVkaXRvci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybXVsYS1lZGl0b3ItaWNvbic7XG4iXX0=