@anyblock/any-block-core 3.4.6

package/ABConvertManager.ts

@@ -0,0 +1,266 @@
+/** 
+ * @detail
+ * 具体用法和介绍等见 README.md
+ * 
+ * 依赖顺序
+ * 1. ABConvert.ts，转换器的抽象基类
+ * 2. ABConvertManager.ts，转换器的容器
+ * 3. ……，其他具体的转换器
+ * 
+ * 跨平台兼容依赖问题
+ * - 在Obsidian环境，能够使用document
+ * - 在vuepress和mdit环境，他是使用纯文本来解析渲染md而非面向对象，也不依赖document。所以为了兼顾这个，需要额外安装Node.js中能使用的[jsdom](https://github.com/jsdom/jsdom)
+ * 
+ * jsdom 老install失败。网上搜说：
+ * a: jsdom 依赖于 contextify，而 contextify 最近才支持 windows。安装它需要 python 和 C++ 编译器。
+ * b: jsdom 使用 contextify 在 DOM 上运行 JavaScript。而 contextify 需要本地 C++ 编译器。根据官方自述，在 Windows 平台上必须安装一堆东西
+ * 不过我后来尝试按一个回答中那样指定了版本就可以了：npm install -D jsdom@4.2.0
+ */
+
+// AB转换器容器
+import {
+  ABConvert_IOEnum, 
+  type ABConvert_IOType, 
+  ABConvert
+} from './converter/ABConvert'
+import { autoABAlias } from "./ABAlias"
+import { ABCSetting } from "./ABSetting"
+ 
+/**
+  * AB转换器的管理器。注意：使用前必须先执行：`redefine_renderMarkdown`
+  * 
+  * @default
+  * 单例模式 
+  * 负责转换器的：注册、寻找、依次使用
+  */
+export class ABConvertManager {
+
+  /** --------------------------------- 特殊函数 ---------------------------- */
+
+  /// 单例模式
+  static getInstance(): ABConvertManager {
+    if (!ABConvertManager.m_instance) {
+      ABConvertManager.m_instance = new ABConvertManager()
+    }
+    return ABConvertManager.m_instance;
+  }
+
+  /// 单例
+  private static m_instance: ABConvertManager
+
+  /// 构造函数
+  private constructor() {
+    /// 环境打印 (编译期打印)
+    // @ts-ignore 用于检查obsidian是否存在，不存在的话正常是飘红的
+    if (typeof obsidian == 'undefined' && typeof app == 'undefined') {
+      console.log('[environment]: markdown-it, without obsidian')
+    } else {
+      console.log('[environment]: obsidian')
+    }
+  }
+
+  /** --------------------------------- 处理器容器管理 --------------------- */
+
+  /// ab处理器 - 严格版，的接口与列表 (动态)
+  public list_abConvert: ABConvert[] = []
+
+  /// 处理器一览表 - 下拉框推荐
+  public getConvertOptions(){
+    return this.list_abConvert
+    .filter(item=>{
+      return item.default
+    })
+    .map(item=>{
+      return {id:item.default, name:item.name}
+    })
+  }
+
+  /** --------------------------------- 通用解耦适配 (动态) ----------------- */
+
+  /**
+   * 渲染文本为html
+   * @detail 这里需要能够被回调函数替换。从而用于接回软件自身的html渲染机制，来进行解耦
+   * @param markdown 原md
+   * @param el 要追加到的元素
+   * @param ctx Obsidian在这里需要传入 MarkdownRenderChild 类型，但为了跨平台我这里修改成可选的any类型
+   */
+  public m_renderMarkdownFn:(markdown: string, el: HTMLElement, ctx?: any) => void = (markdown, el) => {
+    el.classList.add("markdown-rendered") // 并注意，应当在使用该函数前将el添加该css类，或者重定义时增加该条语句
+    console.error("Please use renderMarkdownFn redefine render function")
+  }
+
+  /// 用回调函数替换重渲染器
+  public redefine_renderMarkdown(callback: (markdown: string, el: HTMLElement, ctx?: any) => void) {
+    this.m_renderMarkdownFn = callback
+  }
+
+  /** --------------------------------- 处理器的调用 ----------------------- */
+  
+  static startTime: number; // cache
+  /**
+   * 自动寻找相匹配的ab处理器进行处理
+   * 
+   * @detail
+   *     ab转换器能根据header和content来将有段txt文本转换为html元素
+   *     主要分三个过程：
+   *     1. 预处理
+   *     2. 递归处理
+   *     3. 尾处理 (其实尾处理也可以归到预处理那)
+   * @param el 最后的渲染结果
+   * @param header 转换方式
+   * @param content 要转换的初始文本 (无前缀版本，前缀在选择器环节已经删除了)
+   * @param selectorName 选择器名，空表示未知
+   * @return 等于el，无用，后面可以删了
+   */
+  public static autoABConvert(el:HTMLDivElement, header:string, content:string, selectorName:string = "", ctx?: any): void{
+    let prev_result: ABConvert_IOType = content               // 上次转换后的结果，初始必为string
+    let prev_type: string = "string"                          // 上次转换后的结果的类型 (类型检测而来)
+    let prev_type2: ABConvert_IOEnum = ABConvert_IOEnum.text  // 上次转换后的结果的类型 (接口声明而来)
+    let prev_processor;                                       // 上一次转换的处理器
+    let prev = {                                              // 组合在一起是为了引用传参
+      prev_result, prev_type, prev_type2, prev_processor
+    }
+
+    if (false && ABCSetting.is_debug) ABConvertManager.startTime = performance.now();
+    {
+      header = autoABAlias(header, selectorName, prev_result as string);
+      let list_header = header.split("|")
+      prev_result = this.autoABConvert_runConvert(el, list_header, prev, ctx)
+      this.autoABConvert_last(el, header, selectorName, prev, ctx)
+    }
+    if (false && ABCSetting.is_debug) {
+      const endTime = performance.now();
+      console.log(`Takes ${(endTime - ABConvertManager.startTime).toFixed(2)} ms when selector "${selectorName}" header "${header}"`);
+    }
+  }
+
+  /**
+   * autoABConvert的递归子函数
+   * @param el 
+   * @param list_header 
+   * @param prev_result 上次转换后的结果
+   * @param prev_type   上次转换后的结果的类型 (类型检测而来, typeof类型)
+   * @param prev_type2  上次转换后的结果的类型 (接口声明而来, IOEnum类型)
+   * @returns           递归转换后的结果
+   */
+  private static autoABConvert_runConvert(el:HTMLDivElement, list_header:string[], prev:any, ctx?: any):any{
+    // 循环header组，直到遍历完文本处理器或遇到渲染处理器
+    for (let item_header of list_header){ // TODO 因为可能被插入新的“中间自动转换器”，要么for替换成递归，要么都在头部预处理时弄完
+      for (let abReplaceProcessor of ABConvertManager.getInstance().list_abConvert){
+        // 通过header寻找处理器
+        if (typeof(abReplaceProcessor.match)=='string'){if (abReplaceProcessor.match!=item_header) continue}
+        else {if (!abReplaceProcessor.match.test(item_header)) continue}
+        // TODO 删除旧的别名系统
+        // 检查是否有别名。若是，递归
+        if(abReplaceProcessor.process_alias){
+          // 别名支持引用正则参数
+          let alias = abReplaceProcessor.process_alias
+          ;(()=>{
+            if (abReplaceProcessor.process_alias.indexOf("%")<0) return
+            if (typeof(abReplaceProcessor.match)=="string") return
+            const matchs = item_header.match(abReplaceProcessor.match)
+            if (!matchs) return
+            const len = matchs.length
+            if (len==1) return
+            // replaceAlias
+            for (let i=1; i<len; i++){
+              if (!matchs[i]) continue
+              alias = alias.replace(RegExp(`%${i}`), matchs[i]) /** @bug 按理应该用`(?<!\\)%${i}`，但ob不支持正则的向前查找 */
+            }
+          })()
+          prev.prev_result = this.autoABConvert_runConvert(el, alias.split("|"), prev, ctx)
+        }
+        // 若不是，使用process方法
+        else if(abReplaceProcessor.process){
+          // (1) 检查输入类型
+          if (abReplaceProcessor.process_param != prev.prev_type2){
+            // TODO，两个自动处理器，后面要被别名系统替换掉
+            if (abReplaceProcessor.process_param==ABConvert_IOEnum.el &&
+              prev.prev_type2==ABConvert_IOEnum.text
+            ){ // 需要输入html，实际输入md，则插入一个md->html
+              const subEl: HTMLDivElement = document.createElement("div"); el.appendChild(subEl);
+              ABConvertManager.getInstance().m_renderMarkdownFn(prev.prev_result, subEl);
+              prev.prev_result = el
+              prev.prev_type = typeof(prev.prev_result)
+              prev.prev_type2 = ABConvert_IOEnum.el
+              prev.prev_processor = "md"
+            }
+            else if (abReplaceProcessor.process_param==ABConvert_IOEnum.text &&
+              (prev.prev_type2==ABConvert_IOEnum.list_stream || prev.prev_type2==ABConvert_IOEnum.c2list_stream)
+            ) { // 需要输入text，实际输入object，则插入一个object->text
+              prev.prev_result = JSON.stringify(prev.prev_result, null, 2)
+              prev.prev_type = typeof(prev.prev_result)
+              prev.prev_type2 = ABConvert_IOEnum.text
+              prev.prev_processor = "stream to text"
+            }
+            else if (abReplaceProcessor.process_param==ABConvert_IOEnum.text &&
+              prev.prev_type2==ABConvert_IOEnum.json
+            ) {
+              prev.prev_type2 = ABConvert_IOEnum.text
+              prev.prev_processor = "json to text"
+            }
+            else{
+              console.warn(`处理器输入类型错误, id:${abReplaceProcessor.id}, virtualParam:${abReplaceProcessor.process_param}, realParam:${prev.prev_type2}`);
+              break
+            }
+          }
+
+          // (2) 执行处理器
+          prev.prev_result = abReplaceProcessor.process(el, item_header, prev.prev_result, ctx)
+          prev.prev_type = typeof(prev.prev_result)
+          prev.prev_type2 = abReplaceProcessor.process_return as ABConvert_IOEnum
+          prev.prev_processor = abReplaceProcessor.process
+
+          // (3) 检查输出类型
+          // if(typeof(prev_result) == "string"){prev_type = ABConvert_IOEnum.text}
+          // 下行换成了下下行。因为下行在mdit/jsdom环境可能报错：Right-hand side of 'instanceof' is not callable
+          //else if (prev_result instanceof HTMLElement){prev_type = ABConvert_IOType.el}
+          // else if (typeof(prev_result) == "object"){prev_type = ABConvert_IOEnum.el}
+          // else {
+          //   console.warn(`处理器输出类型错误, id:${abReplaceProcessor.id}, virtualReturn:${abReplaceProcessor.process_return}, realReturn${prev_type}`);
+          //   break
+          // }
+        }
+        else{
+          console.warn("处理器必须实现process或process_alias方法")
+        }
+      }
+    }
+    return prev
+  }
+
+  /**
+   * 子函数，后处理/尾处理，主要进行末尾追加指令
+   */
+  private static autoABConvert_last (el:HTMLDivElement, header:string, selectorName:string, prev:any, ctx?: any):any{
+    // text内容，则给一个md渲染器
+    if (prev.prev_type == "string" && prev.prev_type2 == ABConvert_IOEnum.text) {
+      const subEl = document.createElement("div"); el.appendChild(subEl);
+      ABConvertManager.getInstance().m_renderMarkdownFn(prev.prev_result as string, subEl);
+      prev.prev_result = el; prev.prev_type = "object"; prev.prev_type2 = ABConvert_IOEnum.el; prev.process = "md";
+    }
+    // json内容/数组内容，则用代码块表示
+    else if (prev.prev_type == "string" && prev.prev_type2 == ABConvert_IOEnum.json) {
+      const code_str:string = "```json\n" + prev.prev_result + "\n```\n"
+      const subEl = document.createElement("div"); el.appendChild(subEl);
+      ABConvertManager.getInstance().m_renderMarkdownFn(code_str, subEl);
+      prev.prev_result = el; prev.prev_type = "object"; prev.prev_type2 = ABConvert_IOEnum.el; prev.process = "show_json";
+    }
+    // 数组流，用代码块表示
+    else if (prev.prev_type == "object" &&
+      (prev.prev_type2 == ABConvert_IOEnum.list_stream || prev.prev_type2 == ABConvert_IOEnum.c2list_stream || prev.prev_type2 == ABConvert_IOEnum.json)
+    ) {
+      const code_str:string = "```json\n" + JSON.stringify(prev.prev_result, null, 2) + "\n```\n"
+      const subEl = document.createElement("div"); el.appendChild(subEl);
+      ABConvertManager.getInstance().m_renderMarkdownFn(code_str, subEl);
+      prev.prev_result = el; prev.prev_type = "object"; prev.prev_type2 = ABConvert_IOEnum.el; prev.process = "show_listStream";
+    }
+    else if (prev.prev_type == "object" && prev.prev_type2 == ABConvert_IOEnum.el) {
+      return prev
+    }
+    else {
+      console.warn("other type in tail, can not tail processor:", prev.prev_type, prev.prev_type2, prev.prev_result)
+    }
+    return prev
+  }
+}

package/ABSetting.ts

@@ -0,0 +1,114 @@
+/**
+ * @attention 注意: 该文件以前名字为 `ABReg.ts`，注意历史遗留问题
+ */
+
+/**
+ * ABConvert的设置
+ * 
+ * 全平台通用设置
+ * 
+ * @detail
+ * 在 obsidian 环境中，需要保证与 obsidian 设置的一致性 (可以被obsidian的设置修改)
+ * 如果没有GUI设置页面，可以人工修改
+ */
+export const ABCSetting: {
+  is_debug: boolean,
+  env: "obsidian"|"obsidian-min"|"obsidian-pro"|"app"|"markdown-it"|"remark",
+  // 某些环境的独占 api，其他环境用不上
+  obsidian: {
+    global_app: any,
+    global_ctx: any, // MarkdownPostProcessorContext类型, obsidian专用
+    mermaid?: Promise<any>, // obsidian专用，obsidian 如何渲染mermaid
+  },
+  pro: {
+    disable: boolean, // 禁用 pro 版的扩展功能，变为非 pro 版
+    enable_callout_selector: boolean,     // 是否启用 callout 选择器并自动替换 callout 为可编辑 callout
+    enable_alias_override: boolean,       // 启用别名覆盖 (启用后 pro 处理器会使用旧处理器名，并覆盖掉之前的行为)
+    editableblock_defaultRender: 'readmode' | 'realtime' | 'textarea', // 可编辑块的默认渲染模式
+    create_decorations: undefined | ((
+      customData: {
+        cancelFlag: number[];
+        updateMode: string | number;
+      },
+      oldView: any, tr: any, decorationSet: any | undefined, create_widget: any
+    ) => any)
+  },
+  // 运行时状态
+  state: {
+    language: 'en'|'zh'|'zh-TW'|string // 语言 (字典语言标志: 本地化语言名转标志, 不存在语言转en，自动选择转实际语言)
+  },
+} = {
+  is_debug: false,
+  env: "obsidian",
+  // 某些环境的独占 api，其他环境用不上
+  obsidian: {
+    global_app: null,
+    global_ctx: null,
+    mermaid: undefined,
+  },
+  pro: {
+    disable: false,
+    enable_callout_selector: true,
+    enable_alias_override: true,
+    editableblock_defaultRender: 'readmode',
+    create_decorations: undefined
+  },
+  state: {
+    language: 'en',
+  },
+}
+
+/**
+ * 正则匹配规则
+ * 
+ * @attention 注意：修改正则要注意小括号的位置是否对应，不然还要去修改索引
+ */
+export const ABReg = {
+  /**
+   * AB块头部
+   *
+   * 例子：`    > - > %%[d]:%%   `
+   * 
+   * - 前缀部分
+   *     - $1: 前缀 | `    > - >  ` | ((\s|>\s|-\s|\*\s|\+\s)*)
+   *     - $2: 无用 | `>`           | (\s|>\s|-\s|\*\s|\+\s)
+   * - 指令部分
+   *     - $3: 无用 | `%%`          | (%%)?
+   *     - $4：无用 | `[header]`    | (\[((?!toc)[0-9a-zA-Z].*)\])
+   *     - $5：指令 | `header`      | (?!toc)[0-9a-zA-Z].*)
+   *     - $6: 无用 | `%%`          | (%%)?
+   * 
+   * 注意：
+   * - (?!\[) (?!\toc) 这种向后否定语句不作为一个匹配项
+   * - 允许 `%%` 和 `:` 的规则是V3新增的
+   * - 不允许 `::` 是避免与 dataview 的 inline property 冲突
+   */
+  // 有前缀版本（给选择器用）
+  reg_header:   /^((\s|>\s|-\s|\*\s|\+\s)*)(%%)?(\[((?!toc|TOC|\!|< )[\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/, // 可以用空`|`来解除首字符限制。(`|`注意：可以用来弄严格模式，`#`注意：建议后面空一格避免变成“标签”，`!`注意：别易误触发 `> [!note]`
+  reg_header_up:/^((\s|>\s|-\s|\*\s|\+\s)*)(%%)?(\[((?!toc|TOC|\!)< [\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/,  // 向上检查标志的 头部选择器
+  
+  reg_mdit_head:/^((\s|>\s|-\s|\*\s|\+\s)*)(::::*)\s?(.*)/,
+  reg_mdit_tail:/^((\s|>\s|-\s|\*\s|\+\s)*)(::::*)/,
+  reg_list:     /^((\s|>\s|-\s|\*\s|\+\s)*)(-\s|\*\s|\+\s)(.*)/,  //: /^\s*(>\s)*-\s(.*)$/
+  reg_code:     /^((\s|>\s|-\s|\*\s|\+\s)*)(````*|~~~~*)(.*)/,    //: /^\s*(>\s|-\s)*(````*|~~~~*)(.*)$/
+  reg_quote:    /^((\s|>\s|-\s|\*\s|\+\s)*)(>\s)(.*)/,            // `- > ` 不匹配，要认为这种是列表
+  reg_heading:  /^((\s|>\s|-\s|\*\s|\+\s)*)(\#+\s)(.*)/,
+  reg_table:    /^((\s|>\s|-\s|\*\s|\+\s)*)(\|(.*)\|)/,
+
+  // 无前缀版本（给处理器用，处理器不需要处理前缀，前缀在选择器阶段已经被去除了）
+  reg_header_noprefix:   /^((\s)*)(%%)?(\[((?!toc|TOC|\!|< )[\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/,
+  reg_header_up_noprefix:/^((\s)*)(%%)?(\[((?!toc|TOC|\!)< [\|\!#:;\(\)\s0-9a-zA-Z\u4e00-\u9fa5](?!.*::).*)\]):?\3\s*$/,
+  
+  reg_mdit_head_noprefix:/^((\s)*)(::::*)\s?(.*)/,
+  reg_mdit_tail_noprefix:/^((\s)*)(::::*)/,
+  reg_list_noprefix:     /^((\s)*)(-\s|\*\s|\+\s)(.*)/,
+  reg_code_noprefix:     /^((\s)*)(````*|~~~~*)(.*)/,
+  reg_quote_noprefix:    /^((\s)*)(>\s)(.*)/,
+  reg_heading_noprefix:  /^((\s)*)(\#+\s)(.*)/,
+  reg_table_noprefix:    /^((\s)*)(\|(.*)\|)/,
+
+  reg_emptyline_noprefix:/^\s*$/,
+  reg_indentline_noprefix:/^\s+?\S/,
+
+  inline_split: /\| |,  |， |\.  |。 |:  |： /, // 内联切分。`|`或全角符号+一空格，半角符号+两空格 (后者由于空格压缩，若经历了重渲染可能有问题)
+}