@gmb/bitmark-parser-generator 5.15.0 → 5.17.0

package/dist/cli/main.js

@@ -10876,7 +10876,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.15.0",
+  "version": "5.17.0",
   "license": "ISC"};
 var Environment = {
   unknown: "",
@@ -11107,6 +11107,16 @@ var TextMarkType = {
   light: "light",
   italic: "italic",
   highlight: "highlight",
+  highlightOrange: "highlightOrange",
+  highlightYellow: "highlightYellow",
+  highlightGreen: "highlightGreen",
+  highlightBlue: "highlightBlue",
+  highlightPurple: "highlightPurple",
+  highlightPink: "highlightPink",
+  highlightBrown: "highlightBrown",
+  highlightBlack: "highlightBlack",
+  highlightWhite: "highlightWhite",
+  highlightGray: "highlightGray",
   // Inline only styles
   strike: "strike",
   subscript: "subscript",
@@ -12601,6 +12611,16 @@ var STANDARD_MARK_TYPES = [
   TextMarkType.highlight
 ];
 var INLINE_MARK_TYPES = [
+  TextMarkType.highlightOrange,
+  TextMarkType.highlightYellow,
+  TextMarkType.highlightGreen,
+  TextMarkType.highlightBlue,
+  TextMarkType.highlightPurple,
+  TextMarkType.highlightPink,
+  TextMarkType.highlightBrown,
+  TextMarkType.highlightBlack,
+  TextMarkType.highlightWhite,
+  TextMarkType.highlightGray,
   TextMarkType.strike,
   TextMarkType.subscript,
   TextMarkType.superscript,
@@ -39294,6 +39314,265 @@ var JsonFileGenerator = class {
     this.generator.generateSync(_ast);
   }
 };
+
+// src/generator/plainText/PlainTextGenerator.ts
+var TEXT_NODE_TYPES = new Set(Object.values(TextNodeType));
+var PlainTextGenerator = class {
+  /**
+   * Generate plain text from a string or JSON object.
+   *
+   * @param input - A string (plain or JSON-encoded) or a parsed JSON value.
+   * @returns The extracted plain text.
+   */
+  generate(input) {
+    let data = input;
+    if (typeof data === "string") {
+      try {
+        data = JSON.parse(data);
+      } catch (_e) {
+        return data;
+      }
+    }
+    return this.walk(data).trim();
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  walk(value) {
+    if (value == null) return "";
+    if (typeof value === "string") return value;
+    if (typeof value !== "object") return "";
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "";
+      if (this.isTextAst(value)) {
+        return this.textAstToPlainText(value);
+      }
+      return value.map((v) => this.walk(v)).filter(Boolean).join("\n");
+    }
+    const obj = value;
+    if (this.isTextNode(obj)) {
+      return this.textNodeToPlainText(obj);
+    }
+    if (this.isBitWrapper(obj)) {
+      return this.walk(obj["bit"]);
+    }
+    const parts = [];
+    for (const val of Object.values(obj)) {
+      if (val == null || typeof val !== "object") continue;
+      const text = this.walk(val);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  // -- Type guards -----------------------------------------------------------
+  isTextNode(obj) {
+    return typeof obj["type"] === "string" && TEXT_NODE_TYPES.has(obj["type"]);
+  }
+  isTextAst(arr) {
+    const first = arr[0];
+    return typeof first === "object" && first !== null && !Array.isArray(first) && this.isTextNode(first);
+  }
+  isBitWrapper(obj) {
+    return "bit" in obj && typeof obj["bit"] === "object" && obj["bit"] !== null && !Array.isArray(obj["bit"]);
+  }
+  // -- TextNode extraction ---------------------------------------------------
+  textAstToPlainText(ast) {
+    return ast.map((node) => this.textNodeToPlainText(node)).join("\n");
+  }
+  textNodeToPlainText(node) {
+    const { type, text, content } = node;
+    switch (type) {
+      case TextNodeType.text:
+        return this.textWithMarks(node);
+      case TextNodeType.hardBreak:
+        return "\n";
+      // Block elements whose children are joined without extra separator
+      case TextNodeType.paragraph:
+      case TextNodeType.heading:
+      case TextNodeType.section:
+      case TextNodeType.gap:
+      case TextNodeType.select:
+      case TextNodeType.highlight:
+      case TextNodeType.mark:
+      case TextNodeType.codeBlock:
+        return content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+      // List items are handled by listToPlainText with indent context
+      case TextNodeType.listItem:
+        return content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+      // Task item – handled by taskListToPlainText, but fallback if encountered standalone
+      case TextNodeType.taskItem: {
+        const checked = node.attrs?.checked ?? false;
+        const prefix = checked ? "[x] " : "[ ] ";
+        const itemText = content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+        return `${prefix}${itemText}`;
+      }
+      // List containers – rendered with indent-aware helper
+      case TextNodeType.noBulletList:
+      case TextNodeType.bulletList:
+      case TextNodeType.orderedList:
+      case TextNodeType.orderedListRoman:
+      case TextNodeType.orderedListRomanLower:
+      case TextNodeType.letteredList:
+      case TextNodeType.letteredListLower:
+        return this.listToPlainText(node, 0);
+      // Task list – rendered with indent-aware helper
+      case TextNodeType.taskList:
+        return this.taskListToPlainText(node, 0);
+      // Images – return alt text when available
+      case TextNodeType.image:
+      case TextNodeType.imageInline: {
+        const attrs = node.attrs;
+        return attrs?.alt ?? "";
+      }
+      // LaTeX – return the formula source
+      case TextNodeType.latex: {
+        const latexAttrs = node.attrs;
+        return latexAttrs?.formula ?? "";
+      }
+      default:
+        return content ? content.map((c) => this.textNodeToPlainText(c)).join("") : text ?? "";
+    }
+  }
+  listToPlainText(node, depth) {
+    const { type, content } = node;
+    if (!content || content.length === 0) return "";
+    const indent = "  ".repeat(depth);
+    const start = node.attrs?.start ?? 1;
+    const displayStart = start < 1 ? start + 1 : start;
+    return content.map((child, i) => {
+      const { inline, nested } = this.splitListItemContent(child, depth);
+      const prefix = this.listItemPrefix(type, displayStart + i);
+      const line = `${indent}${prefix}${inline}`;
+      return nested ? `${line}
+${nested}` : line;
+    }).join("\n");
+  }
+  taskListToPlainText(node, depth) {
+    const { content } = node;
+    if (!content || content.length === 0) return "";
+    const indent = "  ".repeat(depth);
+    return content.map((child) => {
+      const checked = child.attrs?.checked ?? false;
+      const prefix = checked ? "[x] " : "[ ] ";
+      const { inline, nested } = this.splitListItemContent(child, depth);
+      const line = `${indent}${prefix}${inline}`;
+      return nested ? `${line}
+${nested}` : line;
+    }).join("\n");
+  }
+  splitListItemContent(item, depth) {
+    const children = item.content ?? [];
+    const inlineParts = [];
+    const nestedParts = [];
+    for (const child of children) {
+      if (this.isListType(child.type)) {
+        nestedParts.push(this.renderNestedList(child, depth + 1));
+      } else {
+        inlineParts.push(this.textNodeToPlainText(child));
+      }
+    }
+    return {
+      inline: inlineParts.join(""),
+      nested: nestedParts.join("\n")
+    };
+  }
+  isListType(type) {
+    return type === TextNodeType.bulletList || type === TextNodeType.orderedList || type === TextNodeType.orderedListRoman || type === TextNodeType.orderedListRomanLower || type === TextNodeType.letteredList || type === TextNodeType.letteredListLower || type === TextNodeType.noBulletList || type === TextNodeType.taskList;
+  }
+  renderNestedList(node, depth) {
+    if (node.type === TextNodeType.taskList) {
+      return this.taskListToPlainText(node, depth);
+    }
+    return this.listToPlainText(node, depth);
+  }
+  listItemPrefix(listType, index) {
+    switch (listType) {
+      case TextNodeType.bulletList:
+        return "\u2022 ";
+      case TextNodeType.orderedList:
+        return `${index}. `;
+      case TextNodeType.orderedListRoman:
+        return `${this.toRoman(index)}. `;
+      case TextNodeType.orderedListRomanLower:
+        return `${this.toRoman(index).toLowerCase()}. `;
+      case TextNodeType.letteredList:
+        return `${this.toLetter(index)}. `;
+      case TextNodeType.letteredListLower:
+        return `${this.toLetter(index).toLowerCase()}. `;
+      case TextNodeType.noBulletList:
+      default:
+        return "";
+    }
+  }
+  toRoman(num) {
+    const romanNumerals = [
+      [1e3, "M"],
+      [900, "CM"],
+      [500, "D"],
+      [400, "CD"],
+      [100, "C"],
+      [90, "XC"],
+      [50, "L"],
+      [40, "XL"],
+      [10, "X"],
+      [9, "IX"],
+      [5, "V"],
+      [4, "IV"],
+      [1, "I"]
+    ];
+    let result = "";
+    let remaining = num;
+    for (const [value, numeral] of romanNumerals) {
+      while (remaining >= value) {
+        result += numeral;
+        remaining -= value;
+      }
+    }
+    return result;
+  }
+  toLetter(num) {
+    let result = "";
+    let remaining = num;
+    while (remaining > 0) {
+      remaining--;
+      result = String.fromCharCode(65 + remaining % 26) + result;
+      remaining = Math.floor(remaining / 26);
+    }
+    return result;
+  }
+  textWithMarks(node) {
+    const { text, marks } = node;
+    const parts = [];
+    const linkMark = marks?.find((m) => m.type === "link");
+    const href = linkMark?.attrs?.href;
+    if (text && href && text !== href) {
+      const hrefBare = href.replace(/^https?:\/\//, "");
+      if (text.includes(hrefBare)) {
+        parts.push(text.replace(hrefBare, href));
+      } else if (text.includes(href)) {
+        parts.push(text);
+      } else {
+        parts.push(`${text} ${href}`);
+      }
+    } else if (text) {
+      parts.push(text);
+    } else if (href) {
+      parts.push(href);
+    }
+    if (marks) {
+      for (const mark of marks) {
+        if (mark.type === "footnote") {
+          const footnote = mark;
+          if (footnote.attrs?.content) {
+            const footnoteText = footnote.attrs.content.map((c) => this.textNodeToPlainText(c)).join("");
+            if (footnoteText) parts.push(footnoteText);
+          }
+        }
+      }
+    }
+    return parts.join(" ");
+  }
+};
 var normalizeCardKey = (cardSetKey) => stringUtils.camelToKebab(cardSetKey);
 var ConfigBuilder = class {
   build(options) {
@@ -39995,7 +40274,25 @@ var Output = {
   /**
    * Output AST as a plain JS object, or a file
    */
-  ast: "ast"
+  ast: "ast",
+  /**
+   * Output plain text as a string, or a file
+   */
+  text: "text"
+};
+var InputFormat = {
+  /**
+   * Input is bitmark
+   */
+  bitmark: "bitmark",
+  /**
+   * Input is bitmarkText
+   */
+  bitmarkText: "bitmarkText",
+  /**
+   * Input is plain text
+   */
+  plainText: "plainText"
 };
 var BitmarkParserGenerator = class {
   ast = new Ast();
@@ -40079,6 +40376,12 @@ var BitmarkParserGenerator = class {
    * - input(JSON/AST) ==> output(bitmark)
    * - input(bitmark)  ==> output(JSON)
    *
+   * Output type can be overridden to one of the following:
+   * - bitmark: output bitmark string
+   * - json: output JSON as a plain JS object, or a file
+   * - ast: output AST as a plain JS object, or a file
+   * - text: output plain text as a string, or a file
+   *
    * By default, the result is returned as a string for bitmark, or a plain JS object for JSON/AST.
    *
    * The options can be used to write the output to a file and to set conversion options or override defaults.
@@ -40101,6 +40404,7 @@ var BitmarkParserGenerator = class {
     const outputBitmark = outputFormat === Output.bitmark;
     const outputJson = outputFormat === Output.json;
     const outputAst = outputFormat === Output.ast;
+    const outputText = outputFormat === Output.text;
     const bitmarkParserType = BitmarkParserType.peggy;
     let inStr = input;
     const inputIsString = typeof input === "string";
@@ -40147,6 +40451,22 @@ var BitmarkParserGenerator = class {
         }
       }
     };
+    const bitmarkToText = (bitmarkStr) => {
+      ast = this.bitmarkParser.toAst(bitmarkStr, {
+        parserType: bitmarkParserType
+      });
+      const jsonGenerator = new JsonObjectGenerator(opts);
+      const json = jsonGenerator.generateSync(ast);
+      const textGenerator = new PlainTextGenerator();
+      const str = textGenerator.generate(json);
+      if (opts.outputFile) {
+        fs3.writeFileSync(opts.outputFile, str, {
+          encoding: "utf8"
+        });
+      } else {
+        res = str;
+      }
+    };
     const astToBitmark = (astJson) => {
       if (opts.outputFile) {
         const generator = new BitmarkFileGenerator(opts.outputFile, opts);
@@ -40169,6 +40489,19 @@ var BitmarkParserGenerator = class {
         res = this.jsonStringifyPrettify(json, jsonOptions);
       }
     };
+    const astToText = (astJson) => {
+      const jsonGenerator = new JsonObjectGenerator(opts);
+      const json = jsonGenerator.generateSync(astJson);
+      const textGenerator = new PlainTextGenerator();
+      const str = textGenerator.generate(json);
+      if (opts.outputFile) {
+        fs3.writeFileSync(opts.outputFile, str, {
+          encoding: "utf8"
+        });
+      } else {
+        res = str;
+      }
+    };
     const jsonToBitmark = (astJson) => {
       if (opts.outputFile) {
         const generator = new BitmarkFileGenerator(opts.outputFile, opts);
@@ -40181,6 +40514,19 @@ var BitmarkParserGenerator = class {
     const jsonToAst = (astJson) => {
       res = this.jsonStringifyPrettify(astJson, jsonOptions);
     };
+    const jsonToText = (astJson) => {
+      const jsonGenerator = new JsonObjectGenerator(opts);
+      const json = jsonGenerator.generateSync(astJson);
+      const textGenerator = new PlainTextGenerator();
+      const str = textGenerator.generate(json);
+      if (opts.outputFile) {
+        fs3.writeFileSync(opts.outputFile, str, {
+          encoding: "utf8"
+        });
+      } else {
+        res = str;
+      }
+    };
     const jsonToJson = (astJson) => {
       astToJson(astJson);
     };
@@ -40189,6 +40535,8 @@ var BitmarkParserGenerator = class {
         bitmarkToBitmark(inStr);
       } else if (outputAst) {
         bitmarkToAst(inStr);
+      } else if (outputText) {
+        bitmarkToText(inStr);
       } else {
         bitmarkToJson(inStr);
       }
@@ -40198,6 +40546,8 @@ var BitmarkParserGenerator = class {
         astToAst(ast);
       } else if (outputJson) {
         astToJson(ast);
+      } else if (outputText) {
+        astToText(ast);
       } else {
         astToBitmark(ast);
       }
@@ -40207,6 +40557,8 @@ var BitmarkParserGenerator = class {
         jsonToJson(ast);
       } else if (outputAst) {
         jsonToAst(ast);
+      } else if (outputText) {
+        jsonToText(ast);
       } else {
         jsonToBitmark(ast);
       }
@@ -40335,7 +40687,7 @@ var BitmarkParserGenerator = class {
     return res;
   }
   /**
-   * Convert bitmark text from JSON, or JSON to bitmark text.
+   * Convert bitmark text to JSON, or JSON to bitmark text.
    *
    * Input type is detected automatically and may be:
    * - string: bitmark text or JSON
@@ -40409,6 +40761,54 @@ var BitmarkParserGenerator = class {
     }
     return res;
   }
+  extractPlainText(input, options) {
+    const dataIn = input;
+    const inputFormat = options?.inputFormat;
+    const isString2 = typeof input === "string";
+    let data;
+    const parseAutomatically = () => {
+      let dataOut = dataIn;
+      if (typeof dataIn === "string") {
+        try {
+          dataOut = JSON.parse(dataIn);
+        } catch (_e) {
+          let isBitmark = false;
+          const bitmarkData = this.convert(dataIn, {
+            outputFormat: Output.json
+          });
+          if (bitmarkData.length > 0) {
+            const isError = bitmarkData[0].bit.type === BitType._error;
+            if (!isError) {
+              isBitmark = true;
+              dataOut = bitmarkData;
+            }
+          }
+          if (!isBitmark) {
+            dataOut = this.convertText(dataIn, {
+              textFormat: TextFormat.bitmarkText
+            });
+          }
+        }
+      }
+      return dataOut;
+    };
+    if (inputFormat === InputFormat.bitmark) {
+      data = this.convert(dataIn, {
+        outputFormat: Output.json
+      });
+    } else if (inputFormat === InputFormat.bitmarkText) {
+      data = this.convertText(dataIn, {
+        textFormat: TextFormat.bitmarkText
+      });
+    } else if (inputFormat === InputFormat.plainText) {
+      if (isString2) data = String(input);
+    } else {
+      data = parseAutomatically();
+    }
+    const generator = new PlainTextGenerator();
+    const res = generator.generate(data);
+    return res;
+  }
   /**
    * Breakscape bitmark text.
    *
@@ -40516,6 +40916,16 @@ var BitmarkParserGenerator = class {
     }
     return;
   }
+  textAstToPlainText(textAst, _options) {
+    const textGenerator = new TextGenerator(BitmarkVersion.v3, {
+      //
+    });
+    const res = textGenerator.generateSync(textAst, TextFormat.bitmarkText, TextLocation.body, {
+      noBreakscaping: true,
+      noMarkup: true
+    });
+    return res;
+  }
   /**
    * Stringify / prettify a plain JS object to a JSON string, depending on the JSON options
    *
@@ -40773,6 +41183,42 @@ Examples:
   );
   return cmd;
 }
+var INPUT_FORMAT_CHOICES = enumChoices(InputFormat);
+function createExtractPlainTextCommand() {
+  const bpg = new BitmarkParserGenerator();
+  const cmd = new Command("extractPlainText").description("Extract plain text from bitmark, bitmark text, or JSON").argument(
+    "[input]",
+    "file to read, or text or json string. If not specified, input will be from <stdin>"
+  ).addOption(
+    new Option(
+      "-f, --inputFormat <format>",
+      "force input format (auto-detected by default)"
+    ).choices([...INPUT_FORMAT_CHOICES])
+  ).option("-a, --append", "append to the output file (default is to overwrite)").option("-o, --output <file>", "output file. If not specified, output will be to <stdout>").action(async (input, options) => {
+    try {
+      const dataIn = await readInput(input);
+      const result = bpg.extractPlainText(dataIn, {
+        inputFormat: Enum(InputFormat).fromValue(options.inputFormat)
+      });
+      await writeOutput(result ?? "", options.output, options.append);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  }).addHelpText(
+    "after",
+    `
+Examples:
+  $ bitmark-parser extractPlainText '[{"type":"paragraph","content":[{"text":"Hello World","type":"text"}],"attrs":{}}]'
+
+  $ bitmark-parser extractPlainText input.json
+
+  $ bitmark-parser extractPlainText input.json -o output.txt
+
+  $ bitmark-parser extractPlainText -f bitmark input.bitmark`
+  );
+  return cmd;
+}
 var INFO_TYPE_CHOICES = (() => {
   const choices = new Set(enumChoices(InfoType));
   const ordered = [];
@@ -40900,6 +41346,7 @@ async function asyncInit() {
   });
   program.addCommand(createConvertCommand());
   program.addCommand(createConvertTextCommand());
+  program.addCommand(createExtractPlainTextCommand());
   program.addCommand(createBreakscapeCommand());
   program.addCommand(createUnbreakscapeCommand());
   program.addCommand(createInfoCommand());