@anyblock/any-block-core 3.4.6

package/converter/abc_plantuml.ts

@@ -0,0 +1,109 @@
+/**
+ * 转换器_目录树
+ * 
+ * md_str <-> md_str
+ * md_str <-> html
+ */
+
+import DOMPurify from "dompurify"
+import {ABConvert_IOEnum, ABConvert, type ABConvert_SpecSimp} from "./ABConvert"
+import {ListProcess, type List_ListItem} from "./abc_list"
+
+import plantumlEncoder from "plantuml-encoder"
+
+import { list2ActivityDiagramText } from "./abc_plantuml_tools"
+
+const _abc_list2jsontext = ABConvert.factory({
+  id: "json2pumlJson",
+  name: "json到可视化",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    content = "@startjson\n" + content + "\n@endjson\n"
+    render_pumlText(content, el)
+    return el
+  }
+})
+
+const _abc_list2pumlWBS = ABConvert.factory({
+  id: "list2pumlWBS",
+  name: "列表到puml工作分解结构",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    let listdata:List_ListItem = ListProcess.list2data(content)
+    listdata = ListProcess.data2strict(listdata)
+    let newContent = "@startwbs\n"
+    for (let item of listdata) {
+      if (item.content.startsWith("< "))
+        newContent += "*".repeat(item.level+1) + "< " + item.content.slice(2,) + "\n"
+      else
+        newContent += "*".repeat(item.level+1) + " " + item.content + "\n"
+    }
+    newContent += "@endwbs"
+
+    render_pumlText(newContent, el)
+    return el
+  }
+})
+
+const _abc_list2pumlMindmap = ABConvert.factory({
+  id: "list2pumlMindmap",
+  name: "列表到puml思维导图",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    let listdata:List_ListItem = ListProcess.list2data(content)
+    listdata = ListProcess.data2strict(listdata)
+    let newContent = "@startmindmap\n"
+    for (let item of listdata) {
+      newContent += "*".repeat(item.level+1) + " " + item.content + "\n"
+    }
+    newContent += "@endmindmap"
+
+    render_pumlText(newContent, el)
+    return el
+  }
+})
+
+const _abc_list2ActivityDiagramText = ABConvert.factory({
+	id: "list2pumlActivityDiagramText",
+	name: "列表到puml活动图文本",
+	process_param: ABConvert_IOEnum.text,
+	process_return: ABConvert_IOEnum.text,
+	process: (el, header, content: string): string => {
+		return list2ActivityDiagramText(ListProcess.data2strict(ListProcess.list2data(content)))
+	}
+})
+
+const _abc_list2ActivityDiagram = ABConvert.factory({
+	id: "list2pumlActivityDiagram",
+	name: "列表到puml活动图",
+	process_param: ABConvert_IOEnum.text,
+	process_return: ABConvert_IOEnum.el,
+	process: (el, header, content: string): HTMLElement => {
+		const puml = list2ActivityDiagramText(ListProcess.data2strict(ListProcess.list2data(content)))
+		render_pumlText(puml, el)
+		return el
+	}
+})
+
+export async function render_pumlText(text: string, div: HTMLElement) {
+    // 1. 四选一。自己渲 (优缺点见abc_mermaid的相似方法)
+    // 当前mdit和ob使用
+    var encoded = plantumlEncoder.encode(text)
+    let url = 'http://www.plantuml.com/plantuml/img/' + encoded
+    div.innerHTML = DOMPurify.sanitize(`<img src="${url}">`)
+
+    // 2. 四选一。这里给环境渲染 (优缺点见abc_mermaid的相似方法)
+    //ABConvertManager.getInstance().m_renderMarkdownFn("```plantuml\n"+text+"```", div)
+
+    // 3. 四选一。这里不渲，交给上一层让上一层渲 (优缺点见abc_mermaid的相似方法)
+    //div.classList.add("ab-raw")
+    //div.innerHTML = DOMPurify.sanitize(`<div class="ab-raw-data" type-data="plantuml" content-data='${text}'></div>`)
+
+    // 4. 四选一。纯动态/手动渲染 (优缺点见abc_mermaid的相似方法)
+    // ...
+
+    return div
+}

package/converter/abc_plantuml_tools.ts

@@ -0,0 +1,236 @@
+import type { List_ListItem } from "./abc_list"
+
+// start flag
+const KEYWORD_IF = "if "
+const KEYWORD_SWITCH = "switch "
+const KEYWORD_SWITCH2 = "match "  // python use `match, case, case _` instead of `switch, case, default`
+const KEYWORD_WHILE = "while "
+const KEYWORD_GROUP = "group "
+const KEYWORD_PARTITION = "partition "
+const KEYWORD_LANE = "lane "
+// middle/end flag
+const KEYWORD_ELIF = "elif "
+const KEYWORD_ELSEIF = "else if "
+const KEYWORD_ELSE = "else"
+const KEYWORD_DEFAULT = "default"
+const KEYWORD_DEFAULT2 = "case _" // python use `match, case, case _` instead of `switch, case, default`
+const KEYWORD_CASE = "case "
+// other flag
+const BLOCK_START = ":"
+const INDENT = "  ";
+
+class Stat {
+  content: string;
+  level: number;
+  constructor(content: string, level: number) {
+    this.content = content.trim();
+    this.level = level;
+  }
+  // 判断是否为保留字
+  isReservedWord(): boolean {
+    return this.content === "start" || this.content === "stop" || this.content === "kill" ||
+      this.content === "detach" || this.content === "break" || this.content === "end" ||
+      this.content === "fork" || this.content === "fork again" || this.content === "end fork" ||
+      this.content === "end merge";
+  }
+
+  isStatementOfType(...stateType: string[]): boolean {
+    return stateType.some(type => this.content.startsWith(type)) && this.content.endsWith(BLOCK_START);
+  }
+
+  takeTagOfStat(type: string): string {
+    const condition = this.content.substring(type.length, this.content.length - BLOCK_START.length).trim();
+    return condition;
+  }
+}
+
+type ProcessResult = {
+  result: string,
+  nextIndex: number
+};
+
+const statementTypes = {
+  [KEYWORD_IF]: processIfStatement,
+  [KEYWORD_SWITCH]: processSwitchStatement,
+  [KEYWORD_SWITCH2]: processSwitchStatement,
+  [KEYWORD_WHILE]: processWhileStatement,
+  [KEYWORD_GROUP]: processGroupStatement,
+  [KEYWORD_PARTITION]: processPartitionStatement,
+  [KEYWORD_LANE]: processSwimLane
+};
+
+// Process main content, recursively process all items
+function processBlock(stats: Stat[], index: number, parentLevel: number): ProcessResult {
+  let result = "";
+  let next = index;
+  while (next < stats.length && (parentLevel === -1 || stats[next].level > parentLevel)) {
+    const stat = stats[next];
+
+    if (stat.isReservedWord()) {
+      result += stat.content + "\n";
+      next++;
+      continue;
+    }
+
+    let processed = false;
+    for (const [statType, processor] of Object.entries(statementTypes)) {
+      if (stat.isStatementOfType(statType)) {
+        const { result: processedResult, nextIndex: nextNext } = processor(stats, next, statType);
+        result += processedResult;
+        next = nextNext;
+        processed = true;
+        break;
+      }
+    }
+
+    if (processed) continue;
+
+    if (stat.content.length > 0) {
+      result += `:${stat.content};` + "\n";
+    }
+    next++;
+  }
+
+  return { result, nextIndex: next }
+}
+
+// 处理if语句
+function processIfStatement(stats: Stat[], index: number): { result: string, nextIndex: number } {
+  let result = KEYWORD_IF;
+  const stat = stats[index];
+  const condition = stat.takeTagOfStat(KEYWORD_IF);
+  let nextIndex = index + 1;
+
+  // if body
+  if (nextIndex < stats.length && stats[nextIndex].level > stat.level) {
+    result += `(${condition}) then (yes)\n`;
+    const { result: result2, nextIndex: nextIndex2 } = processBlock(stats, nextIndex, stat.level);
+    result += indentContent(result2);
+    nextIndex = nextIndex2;
+  }
+
+  // Process else and else if branches
+  while (nextIndex < stats.length && stats[nextIndex].level === stat.level && stats[nextIndex].isStatementOfType(KEYWORD_ELIF, KEYWORD_ELSEIF, KEYWORD_ELSE)) {
+    const branch = stats[nextIndex];
+    if (branch.isStatementOfType(KEYWORD_ELSEIF)) { // KEYWORD_ELSEIF must be ahead of ELSE
+      const condition = branch.takeTagOfStat(KEYWORD_ELSEIF);
+      result += `else if(${condition}) then (yes)\n`;
+    } else if (branch.isStatementOfType(KEYWORD_ELIF)) {
+      const condition = branch.takeTagOfStat(KEYWORD_ELIF);
+      result += `else if(${condition}) then (yes)\n`;
+    } else if (branch.isStatementOfType(KEYWORD_ELSE)) {
+      result += `else (else)\n`;
+    }
+    const { result: result2, nextIndex: nextIndex2 } = processBlock(stats, nextIndex + 1, stat.level);
+    result += indentContent(result2);
+    nextIndex = nextIndex2;
+  }
+
+  result += "endif\n";
+  return { result, nextIndex };
+}
+
+// 处理switch语句
+function processSwitchStatement(stats: Stat[], index: number, statType: string): { result: string, nextIndex: number } {
+  let result = `switch `;
+  const stat = stats[index];
+  const condition = stat.takeTagOfStat(statType);
+  let nextIndex = index + 1;
+
+  result += `(${condition})\n`;
+
+  let hasDefault = false;
+  // Process case/default statements
+  while (nextIndex < stats.length && stats[nextIndex].level >= stat.level && stats[nextIndex].isStatementOfType(KEYWORD_CASE, KEYWORD_DEFAULT)) {
+    const nextStat = stats[nextIndex];
+    nextIndex++;
+    if (nextStat.isStatementOfType(KEYWORD_DEFAULT) || nextStat.isStatementOfType(KEYWORD_DEFAULT2)) { // KEYWORD_DEFAULT2 must be ahead of KEYWORD_CASE
+      result += `case (default)\n`;
+      hasDefault = true;
+      const { result: defaultResult, nextIndex: defaultNextIndex } = processBlock(stats, nextIndex, nextStat.level);
+      result += indentContent(defaultResult);
+      nextIndex = defaultNextIndex;
+    } else if (nextStat.isStatementOfType(KEYWORD_CASE)) {
+      const caseTag = nextStat.takeTagOfStat(KEYWORD_CASE);
+      result += `case (${caseTag})\n`;
+      const { result: caseResult, nextIndex: caseNextIndex } = processBlock(stats, nextIndex, nextStat.level);
+      result += indentContent(caseResult);
+      nextIndex = caseNextIndex;
+    } 
+  }
+  if (!hasDefault) {
+    result += "case (default)\n";
+  }
+
+  result += "endswitch\n";
+  return { result, nextIndex };
+}
+
+// 处理while语句
+function processWhileStatement(stats: Stat[], index: number): { result: string, nextIndex: number } {
+  const stat = stats[index];
+  const condition = stat.takeTagOfStat(KEYWORD_WHILE);
+  let result = `${KEYWORD_WHILE}(${condition}) is (true)\n`;
+  let nextIndex = index + 1;
+
+  // Process while body
+  const { result: bodyResult, nextIndex: bodyNextIndex } = processBlock(stats, nextIndex, stat.level);
+  result += indentContent(bodyResult);
+  nextIndex = bodyNextIndex;
+
+  result += "endwhile\n";
+  return { result, nextIndex };
+}
+
+// 处理group语句
+function processGroupStatement(stats: Stat[], index: number): { result: string, nextIndex: number } {
+  const stat = stats[index];
+  const groupName = stat.takeTagOfStat(KEYWORD_GROUP);
+  let result = `${KEYWORD_GROUP}${groupName}\n`;
+  let nextIndex = index + 1;
+
+  // Process group body
+  const { result: bodyResult, nextIndex: bodyNextIndex } = processBlock(stats, nextIndex, stat.level);
+  result += indentContent(bodyResult);
+  nextIndex = bodyNextIndex;
+
+  result += "endgroup\n";
+  return { result, nextIndex };
+}
+
+// 处理partition语句
+function processPartitionStatement(stats: Stat[], index: number): { result: string, nextIndex: number } {
+  const stat = stats[index];
+  const partitionName = stat.takeTagOfStat(KEYWORD_PARTITION);
+  let result = `${KEYWORD_PARTITION}${partitionName} {\n`;
+  let nextIndex = index + 1;
+
+  // Process partition body
+  const { result: bodyResult, nextIndex: bodyNextIndex } = processBlock(stats, nextIndex, stat.level);
+  result += indentContent(bodyResult);
+  nextIndex = bodyNextIndex;
+
+  result += "}\n";
+  return { result, nextIndex };
+}
+
+// 处理swim lane
+function processSwimLane(stats: Stat[], index: number): { result: string, nextIndex: number } {
+  const stat = stats[index];
+  const laneName = stat.takeTagOfStat(KEYWORD_LANE);
+  return { result: "|" + laneName + "|\n", nextIndex: index + 1 };
+}
+
+// 为内容添加缩进
+function indentContent(content: string): string {
+  return content.split('\n').filter(x => x !== '').map(line => INDENT + line).join('\n') + "\n";
+}
+
+export function list2ActivityDiagramText(listdata: List_ListItem): string {
+  let result = "@startuml\n";
+  const stats = listdata.map(item => new Stat(item.content.trim(), item.level));
+  const { result: bodyResult } = processBlock(stats, 0, -1);
+  result += bodyResult;
+  result += "@enduml";
+  return result;
+}

package/converter/abc_table.ts

@@ -0,0 +1,242 @@
+/**
+ * 处理器_表格版
+ * 
+ * - md_str <-> 表格数据
+ * - 表格数据 <-> html
+ * - 列表数据 -> 表格数据
+ */
+
+import { ABReg } from '../ABSetting'
+import {ABConvert_IOEnum, ABConvert, type ABConvert_SpecSimp} from "./ABConvert"
+import {ABConvertManager} from "../ABConvertManager"
+import { type ListItem, type List_ListItem, ListProcess, abc_title2listdata, abc_list2listdata } from "./abc_list"
+import { type C2ListItem, type List_C2ListItem, C2ListProcess } from "./abc_c2list"
+
+/**
+ * 通用表格数据，一个元素等于是一个单元格项 (th/td)
+ * 
+ * 例如：
+ * - a1
+ *   - a2
+ *     - a3
+ *   - b2
+ *     - b3
+ * to
+ * |a1|a2|a3|
+ * |^ |b2|b3|
+ * with
+ * {
+ *   // 前两列是ListItem来的东西
+ *   // 第2列是用来算第3列的，将第3列算出来后，即数据分析完后，第2列就没有用了
+ *   {a1, 无用, 2, 1},
+ *   {a2, 无用, 1, 1},
+ *   {a3, 无用, 1, 1},
+ *   {b2, 无用, 1, 2},
+ *   {b3, 无用, 1, 2},
+ * }
+ */
+export interface TableItem extends ListItem{
+    tableRowSpan: number,       // 跨行数
+    //tableColumnSpan: number,  // 跨列数
+    tableRow: number,           // 对应首行序列
+    //tableColum: number,       // 对应首列序列
+}
+export type List_TableItem = TableItem[]  
+
+/// 一些表格相关的工具集
+export class TableProcess{
+
+  /** 列表转二维表格 */
+  static list2ut(text: string, div: HTMLDivElement, modeT=false) {
+    //【old】
+    /*let list_itemInfo = ListProcess.old_ulist2data(text)
+    return TableProcess.data2table(list_itemInfo, div)*/
+    //【new】
+    let data = ListProcess.list2data(text)
+    data = ListProcess.data2strict(data)
+    data = C2ListProcess.data_mL_2_2L(data)
+    data = ListProcess.data_2L_2_mL1B(data)
+    return TableProcess.data2table(data, div, modeT)
+  }
+
+  /** 列表转时间线 */
+  static list2timeline(text: string, div: HTMLDivElement, modeT=false) {
+    let data = C2ListProcess.list2c2data(text)
+    div = TableProcess.data2table(data, div, modeT)
+    const table = div.querySelector("table")
+    if (table) table.classList.add("ab-table-timeline", "ab-table-fc")
+    return div 
+  }
+
+  /** 标题转时间线 */
+  static title2timeline(text: string, div: HTMLDivElement, modeT=false) {
+    let data = C2ListProcess.title2c2data(text)
+    div = TableProcess.data2table(data, div, modeT)
+    const table = div.querySelector("table")
+    if (table) table.classList.add("ab-table-timeline", "ab-table-fc")
+    return div 
+  }
+
+  /** 列表数据转表格 */
+  static data2table(
+    list_itemInfo: List_ListItem, 
+    div: HTMLDivElement,
+    modeT: boolean        // 是否转置
+  ){
+    // 组装成表格数据 (列表是深度优先)
+    let list_tableInfo:List_TableItem = []
+    let prev_line = -1   // 并存储后一行的序列!
+    let prev_level = 999 // 上一行的等级
+    for (let i=0; i<list_itemInfo.length; i++){
+      let item = list_itemInfo[i]
+      
+      // 获取跨行数
+      let tableRow = 1
+      let row_level = list_itemInfo[i].level
+      for (let j=i+1; j<list_itemInfo.length; j++) {
+        if (list_itemInfo[j].level > row_level){                  // 在右侧，不换行
+          row_level = list_itemInfo[j].level
+        }
+        else if (list_itemInfo[j].level > list_itemInfo[i].level){// 换行但是不换item项的行
+          row_level = list_itemInfo[j].level
+          tableRow++
+        }
+        else break                                                // 换item项的行
+      }
+
+      // 获取所在行数。分换行（创建新行）和不换行，第一行总是创建新行
+      // 这里的if表示该换行了
+      if (item.level <= prev_level) {
+        prev_line++
+      }
+      prev_level = item.level
+
+      // 填写
+      list_tableInfo.push({
+        content: item.content,  // 内容
+        level: item.level,      // 级别
+        tableRowSpan: tableRow,     // 跨行数
+        tableRow: prev_line    // 对应首行序列
+      })
+    }
+
+    // GeneratorBranchTable，原来是svelte
+    {
+      // 表格数据 组装成表格
+      const table = document.createElement("table"); div.appendChild(table); table.classList.add("ab-table", "ab-branch-table")
+      if (modeT) table.setAttribute("modeT", "true")
+      let thead
+      if(list_tableInfo[0].content.indexOf("< ")==0){ // 判断是否有表头
+        thead = document.createElement("thead"); table.appendChild(thead);
+        list_tableInfo[0].content=list_tableInfo[0].content.replace(/^\<\s/,"")
+      }
+      const tbody = document.createElement("tbody"); table.appendChild(tbody);
+      for (let index_line=0; index_line<prev_line+1; index_line++){ // 遍历表格行，创建tr……
+        let is_head
+        let tr
+        if (index_line==0 && thead){ // 判断是否第一行&&是否有表头
+          tr = document.createElement("tr"); thead.appendChild(tr);
+          is_head = true
+        }
+        else{
+          is_head = false
+          tr = document.createElement("tr"); tbody.appendChild(tr);
+        }
+        for (let item of list_tableInfo){                           // 遍历表格列，创建td
+          if (item.tableRow!=index_line) continue
+          let td = document.createElement(is_head?"th":"td"); tr.appendChild(td);
+            td.setAttribute("rowspan", item.tableRowSpan.toString()); td.setAttribute("col_index", item.level.toString())
+          ABConvertManager.getInstance().m_renderMarkdownFn(item.content, td)
+        }
+      }
+    }
+
+    return div
+  }
+}
+
+// 纯组合，后续用别名模块替代
+const _abc_title2table = ABConvert.factory({
+  id: "title2table",
+  name: "标题到表格",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    const data: List_ListItem = abc_title2listdata.process(el, header, content) as List_ListItem
+    return el = TableProcess.data2table(data, el, false) as HTMLDivElement
+  }
+})
+
+// 纯组合，后续用别名模块替代
+const _abc_list2table = ABConvert.factory({
+  id: "list2table",
+  name: "列表转表格",
+  match: /list2(md)?table(T)?/,
+  default: "list2table",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    const matchs = header.match(/list2(md)?table(T)?/)
+    if (!matchs) return el
+    const data: List_ListItem = abc_list2listdata.process(el, header, content) as List_ListItem
+    return el = TableProcess.data2table(data, el, matchs[2]=="T") as HTMLDivElement
+  }
+})
+
+const _abc_list2c2table = ABConvert.factory({
+  id: "list2c2t",
+  name: "列表转二列表格",
+  match: "list2c2t",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    let data = C2ListProcess.list2c2data(content)
+    TableProcess.data2table(data, el, false)
+    return el
+  }
+})
+
+const _abc_list2ut = ABConvert.factory({
+  id: "list2ut",
+  name: "列表转二维表格",
+  match: /list2(md)?ut(T)?/,
+  default: "list2ut",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    const matchs = header.match(/list2(md)?ut(T)?/)
+    if (!matchs) return el
+    TableProcess.list2ut(content, el, matchs[2]=="T")
+    return el
+  }
+})
+
+const _abc_list2timeline = ABConvert.factory({
+  id: "list2timeline",
+  name: "列表转时间线",
+  match: /list2(md)?timeline(T)?/,
+  default: "list2mdtimeline",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    const matchs = header.match(/list2(md)?timeline(T)?/)
+    if (!matchs) return el
+    TableProcess.list2timeline(content, el, matchs[2]=="T")
+    return el
+  }
+})
+
+const _abc_title2timeline = ABConvert.factory({
+  id: "title2timeline",
+  name: "标题转时间线",
+  match: /title2(md)?timeline(T)?/,
+  default: "title2mdtimeline",
+  process_param: ABConvert_IOEnum.text,
+  process_return: ABConvert_IOEnum.el,
+  process: (el, header, content: string): HTMLElement=>{
+    const matchs = header.match(/title2(md)?timeline(T)?/)
+    if (!matchs) return el
+    TableProcess.title2timeline(content, el, matchs[2]=="T")
+    return el
+  }
+})