simple-customize-markdown-converter 1.1.0 → 1.2.0

package/dist/core/parser/handler.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableHandler = exports.StrikethroughHandler = exports.QuoteHandler = exports.NewLineHandler = exports.ListHandler = exports.LinkHandler = exports.ItalicHandler = exports.InlineHandler = exports.ImageHandler = exports.HtmlInlineHandler = exports.HtmlBlockHandler = exports.HorizontalLineHandler = exports.HeaderHandler = exports.FootnoteRefHandler = exports.FootnoteDefHandler = exports.CodeBlockHandler = exports.BoldHandler = void 0;
+const utils = __importStar(require("../../utilities/parser-utils"));
+const CodeBlockHandler = {
+    type: "CodeBlock",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        return {
+            type: "CodeBlock",
+            lang: tok?.type === "CodeBlock" ? tok.lang : "",
+            content: tok?.type === "CodeBlock" ? tok.content : ""
+        };
+    }
+};
+exports.CodeBlockHandler = CodeBlockHandler;
+const HeaderHandler = {
+    type: "Header",
+    execute: (parser, _token) => {
+        const currentNode = parser.peek(0);
+        parser.next(1);
+        return {
+            type: "Header",
+            level: currentNode?.type === "Header" ? currentNode.level : 1,
+            children: parser.parseInlineUntil("NewLine", true) //Temp
+        };
+    },
+};
+exports.HeaderHandler = HeaderHandler;
+const BoldHandler = {
+    type: "Bold",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "Bold", children: parser.parseInlineUntil("Bold", true) };
+    },
+};
+exports.BoldHandler = BoldHandler;
+const ItalicHandler = {
+    type: "Italic",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "Italic", children: parser.parseInlineUntil("Italic", true) };
+    },
+};
+exports.ItalicHandler = ItalicHandler;
+const StrikethroughHandler = {
+    type: "Strikethrough",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "Strikethrough", children: parser.parseInlineUntil("Strikethrough", true) };
+    },
+};
+exports.StrikethroughHandler = StrikethroughHandler;
+const InlineHandler = {
+    type: "InlineCode",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        return {
+            type: "InlineCode",
+            content: tok?.type === "InlineCode" ? tok.content : ""
+        };
+    },
+};
+exports.InlineHandler = InlineHandler;
+const QuoteHandler = {
+    type: "Quote",
+    execute: (parser, _token) => {
+        parser.next(1); //skip marker
+        return { type: "Quote", children: [{ type: "Paragraph", children: parser.parseInlineUntil("NewLine", true) }] };
+    },
+};
+exports.QuoteHandler = QuoteHandler;
+const ListHandler = {
+    type: "ListStart",
+    execute: (parser, _token) => utils.parseList(parser)
+};
+exports.ListHandler = ListHandler;
+const LinkHandler = {
+    type: "Link",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        if (tok?.type === "Link") {
+            return {
+                type: "Link",
+                href: tok.href,
+                text: tok.text
+            };
+        }
+        return { type: "Link", href: "", text: "" };
+    },
+};
+exports.LinkHandler = LinkHandler;
+const ImageHandler = {
+    type: "Image",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        if (tok?.type === "Image") {
+            return {
+                type: "Image",
+                src: tok.src,
+                alt: tok.alt
+            };
+        }
+        else
+            return { type: "Image", src: "", alt: "" };
+    },
+};
+exports.ImageHandler = ImageHandler;
+const TableHandler = {
+    type: "TableStart",
+    execute: (parser, _token) => {
+        parser.next(1); // skip TableStart token
+        const parseRow = () => {
+            const rowStartToken = parser.peek(0);
+            if (rowStartToken?.type !== "RowStart")
+                return { isHeader: false, cells: [] };
+            parser.next(1); // skip RowStart token
+            const cells = [];
+            while (parser.peek(0) && parser.peek(0).type !== "RowEnd") {
+                cells.push(parseCell());
+            }
+            parser.next(1); // skip RowEnd token
+            return {
+                isHeader: rowStartToken.isHeader,
+                cells: cells
+            };
+        };
+        const parseCell = () => {
+            const cellStartToken = parser.peek(0);
+            if (cellStartToken?.type !== "CellStart") {
+                return { align: "left", children: [] };
+            }
+            parser.next(1); // skip CellStart token
+            const childrens = parser.parseInlineUntil("CellEnd", true);
+            return {
+                align: cellStartToken.align || "left",
+                children: childrens
+            };
+        };
+        const rows = [];
+        while (parser.peek(0)?.type !== "TableEnd") {
+            rows.push(parseRow());
+            if (parser.isEnd())
+                break;
+        }
+        parser.next(1);
+        return {
+            type: "Table",
+            rows: rows
+        };
+    },
+};
+exports.TableHandler = TableHandler;
+const HtmlBlockHandler = {
+    type: "HTMLBlock",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1); // skip marker
+        if (tok?.type === "HTMLBlock") {
+            return { type: "HTMLBlock", value: tok.value };
+        }
+        else
+            return { type: "Text", value: "" };
+    },
+};
+exports.HtmlBlockHandler = HtmlBlockHandler;
+const HtmlInlineHandler = {
+    type: "HTMLInline",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1); // skip marker
+        if (tok?.type === "HTMLInline") {
+            return { type: "HTMLInline", value: tok.value };
+        }
+        else
+            return { type: "Text", value: "" };
+    },
+};
+exports.HtmlInlineHandler = HtmlInlineHandler;
+const HorizontalLineHandler = {
+    type: "HorizontalLine",
+    execute: (parser, _token) => {
+        parser.next(1); // skip marker
+        return { type: "HorizontalLine" };
+    },
+};
+exports.HorizontalLineHandler = HorizontalLineHandler;
+const FootnoteDefHandler = {
+    type: "FootnoteDef",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        if (tok?.type === "FootnoteDef" && tok.id) {
+            parser.footNoteResolver.addDef(tok.id, tok.content || "");
+        }
+        parser.next(1);
+    },
+};
+exports.FootnoteDefHandler = FootnoteDefHandler;
+const FootnoteRefHandler = {
+    type: "FootnoteRef",
+    execute: (parser, _token) => {
+        const tok = parser.peek(0);
+        parser.next(1);
+        if (tok?.type !== "FootnoteRef" || !tok.id)
+            return { type: "Text", value: "" };
+        parser.footNoteResolver.addUsedRef(tok.id);
+        return { type: "FootnoteRef", id: tok.id };
+    },
+};
+exports.FootnoteRefHandler = FootnoteRefHandler;
+const NewLineHandler = {
+    type: "NewLine",
+    execute: (parser, _token) => {
+        parser.next(1);
+    },
+};
+exports.NewLineHandler = NewLineHandler;

package/dist/core/parser/index.d.ts

@@ -0,0 +1,33 @@
+import { ASTNode } from '../../types/parser';
+import { Token } from '../../types/token';
+import { FootnoteResolver } from '../resolver/footnote-resolver';
+export interface IParser {
+    listToken: Token[];
+    pos: number;
+    footNoteResolver: FootnoteResolver;
+    peek(offset: number): Token | null;
+    next(amount: number): void;
+    isEnd(): boolean;
+    parseBlocks(): ASTNode[];
+    parseInlineUntil(stopType: Token["type"] | Token["type"][], isConsumeStopToken: boolean): ASTNode[];
+}
+export declare class Parser implements IParser {
+    listToken: Token[];
+    pos: number;
+    footNoteResolver: FootnoteResolver;
+    private inlineStrategies;
+    private blockStrategies;
+    constructor(listToken: Token[], footNoteResolver: FootnoteResolver);
+    peek(offset?: number): Token | null;
+    next(amount?: number): void;
+    isEnd(): boolean;
+    /**
+         * Parse a list token to a node
+         * @return A parsed abstract syntax tree (AST)
+         */
+    parse(): ASTNode;
+    parseBlocks(): ASTNode[];
+    parseInlineUntil(stopType: Token["type"] | Token["type"][], isConsumeStopToken?: boolean): ASTNode[];
+    private parseParagraph;
+    private parseText;
+}

package/dist/core/parser/index.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const Handler = __importStar(require("./handler"));
+class Parser {
+    constructor(listToken, footNoteResolver) {
+        this.pos = 0;
+        this.listToken = listToken;
+        this.footNoteResolver = footNoteResolver;
+        this.blockStrategies = new Map([
+            Handler.HeaderHandler,
+            Handler.CodeBlockHandler,
+            Handler.QuoteHandler,
+            Handler.ImageHandler,
+            Handler.HorizontalLineHandler,
+            Handler.ListHandler,
+            Handler.TableHandler,
+            Handler.HtmlBlockHandler,
+            Handler.FootnoteDefHandler,
+            Handler.NewLineHandler
+        ].map(ele => [ele.type, ele]));
+        this.inlineStrategies = new Map([
+            Handler.BoldHandler,
+            Handler.ItalicHandler,
+            Handler.StrikethroughHandler,
+            Handler.InlineHandler,
+            Handler.LinkHandler,
+            Handler.HtmlInlineHandler,
+            Handler.FootnoteRefHandler,
+        ].map(ele => [ele.type, ele]));
+    }
+    peek(offset = 0) {
+        const i = this.pos + offset;
+        return i < this.listToken.length ? this.listToken[i] : null;
+    }
+    next(amount = 1) {
+        this.pos += amount;
+    }
+    isEnd() {
+        return this.peek()?.type === "EOF";
+    }
+    /**
+         * Parse a list token to a node
+         * @return A parsed abstract syntax tree (AST)
+         */
+    parse() {
+        return {
+            type: "Document",
+            children: this.parseBlocks()
+        };
+    }
+    parseBlocks() {
+        const listNode = [];
+        while (!this.isEnd()) {
+            const token = this.peek();
+            if (!token)
+                break;
+            const strategy = this.blockStrategies.get(token?.type || "");
+            if (strategy) {
+                const result = strategy.execute(this, token);
+                if (result)
+                    listNode.push(result);
+            }
+            else {
+                //Fallback to Paragraph node
+                const pNode = this.parseParagraph();
+                if (pNode.children && pNode.children.length > 0) {
+                    listNode.push(pNode);
+                }
+                else {
+                    this.next();
+                }
+            }
+        }
+        return listNode;
+    }
+    parseInlineUntil(stopType, isConsumeStopToken = false) {
+        const stop = Array.isArray(stopType) ? stopType : [stopType];
+        const nodes = [];
+        while (!this.isEnd()) {
+            const currentNode = this.peek();
+            if (!currentNode || stop.includes(currentNode.type))
+                break;
+            if (this.blockStrategies.get(currentNode.type)) {
+                break;
+            }
+            const strategy = this.inlineStrategies.get(currentNode.type);
+            if (strategy) {
+                const result = strategy.execute(this, currentNode);
+                if (result)
+                    nodes.push(result);
+            }
+            else {
+                //Fallback to Text node
+                nodes.push(this.parseText(currentNode));
+                this.next();
+            }
+        }
+        if (isConsumeStopToken)
+            this.next(); //Skip stop token
+        return nodes;
+    }
+    parseParagraph() {
+        return {
+            type: "Paragraph",
+            children: this.parseInlineUntil("NewLine", true)
+        };
+    }
+    parseText(currentNode) {
+        return {
+            type: "Text",
+            value: currentNode.value || ""
+        };
+    }
+}
+exports.Parser = Parser;

package/dist/core/resolver/footnote-resolver.d.ts

@@ -0,0 +1,15 @@
+declare abstract class Resolver {
+    abstract isResolverValid(): boolean;
+}
+export declare class FootnoteResolver extends Resolver {
+    private defs;
+    private usedRef;
+    addDef(id: string, content: string): void;
+    addUsedRef(id: string): void;
+    resolve(id: string): string | undefined;
+    getUsedRef(): string[];
+    getUsedRefById(id: string): number;
+    getDef(id: string): string | undefined;
+    isResolverValid(): boolean;
+}
+export {};

package/dist/core/resolver/footnote-resolver.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FootnoteResolver = void 0;
+class Resolver {
+}
+class FootnoteResolver extends Resolver {
+    constructor() {
+        super(...arguments);
+        this.defs = new Map();
+        this.usedRef = [];
+    }
+    addDef(id, content) {
+        this.defs.set(id, content);
+    }
+    addUsedRef(id) {
+        if (!this.usedRef.includes(id)) {
+            this.usedRef.push(id);
+        }
+    }
+    resolve(id) {
+        return this.defs.get(id);
+    }
+    getUsedRef() {
+        return this.usedRef;
+    }
+    getUsedRefById(id) {
+        return this.usedRef.indexOf(id) + 1;
+    }
+    getDef(id) {
+        return this.defs.get(id);
+    }
+    isResolverValid() {
+        return this.defs.size !== 0 && this.usedRef.length !== 0;
+    }
+}
+exports.FootnoteResolver = FootnoteResolver;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { MarkdownDefaultOptions } from "./types/options";
-import { RenderOption } from "./types/options/renderOptions";
-import { Node } from "./types/node";
-export { RenderOption, MarkdownDefaultOptions, Node };
+import { MarkdownOptions } from "./types/options";
+import { Token, TokenizerStrategy } from './types/token';
+import { ASTNode, ParsingStrategy } from './types/parser';
+import { RenderStrategy } from './types/renderer';
+export { MarkdownOptions, Token, TokenizerStrategy, ASTNode, ParsingStrategy, RenderStrategy };
 /**
  * Convert a Markdown string into HTML.
  * @param input - The Markdown source string
@@ -14,4 +15,4 @@ export { RenderOption, MarkdownDefaultOptions, Node };
  * // => <p>Hello <strong>world</strong></p>
  * ```
  */
-export declare function convertMarkdownToHTML(input: string, options?: MarkdownDefaultOptions): string;
+export declare function convertMarkdownToHTML(input: string, options?: MarkdownOptions<string>): string;

package/dist/index.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertMarkdownToHTML = convertMarkdownToHTML;
 const lexer_1 = __importDefault(require("./core/lexer"));
 const parser_1 = require("./core/parser");
-const resolver_1 = require("./core/resolver");
-const default_1 = __importDefault(require("./renderers/default"));
+const footnote_resolver_1 = require("./core/resolver/footnote-resolver");
+const default_1 = require("./renderers/default");
 /**
  * Convert a Markdown string into HTML.
  * @param input - The Markdown source string
@@ -25,7 +25,7 @@ function convertMarkdownToHTML(input, options = {
     converterOptions: { allowDangerousHtml: false }
 }) {
     const tokens = new lexer_1.default(input).tokenize();
-    const footNoteResolver = new resolver_1.FootnoteResolver();
+    const footNoteResolver = new footnote_resolver_1.FootnoteResolver();
     const nodes = new parser_1.Parser(tokens, footNoteResolver).parse();
-    return new default_1.default(options, footNoteResolver).render(nodes);
+    return new default_1.DefaultRenderer(footNoteResolver, options).render(nodes);
 }

package/dist/react.d.ts

@@ -1,8 +1,5 @@
 import React from "react";
-import { ReactRenderOption } from "./types/options/reactRenderOptions";
-import { MarkdownReactOptions } from "./types/options";
-import { Node } from "./types/node";
-export { MarkdownReactOptions, ReactRenderOption, Node };
+import { MarkdownOptions } from "./types/options";
 /**
  * Convert a Markdown string into a ReactNode.
  * @param input - The Markdown source string
@@ -16,7 +13,7 @@ export { MarkdownReactOptions, ReactRenderOption, Node };
  * return <div>{node}</div>;
  * ```
  */
-export declare function convertMarkdownToReactNode(input: string, options?: MarkdownReactOptions): React.ReactNode;
+export declare function convertMarkdownToReactNode(input: string, options?: MarkdownOptions<React.ReactNode>): React.ReactNode;
 /**
  * A React commponent that renders Markdown content.
  * Using `React.useMemo` to ensure performance and prevent unnecessary re-render.
@@ -34,6 +31,6 @@ export declare function convertMarkdownToReactNode(input: string, options?: Mark
  */
 export declare const MarkdownComponent: React.FC<{
     content: string;
-    options?: MarkdownReactOptions;
+    options?: MarkdownOptions<React.ReactNode>;
     className?: string;
 }>;

package/dist/react.js

@@ -7,9 +7,9 @@ exports.MarkdownComponent = void 0;
 exports.convertMarkdownToReactNode = convertMarkdownToReactNode;
 const react_1 = __importDefault(require("react"));
 const lexer_1 = __importDefault(require("./core/lexer"));
-const resolver_1 = require("./core/resolver");
 const parser_1 = require("./core/parser");
-const react_2 = __importDefault(require("./renderers/react"));
+const footnote_resolver_1 = require("./core/resolver/footnote-resolver");
+const react_2 = require("./renderers/react");
 /**
  * Convert a Markdown string into a ReactNode.
  * @param input - The Markdown source string
@@ -28,9 +28,9 @@ function convertMarkdownToReactNode(input, options = {
     converterOptions: { allowDangerousHtml: false }
 }) {
     const tokens = new lexer_1.default(input).tokenize();
-    const footNoteResolver = new resolver_1.FootnoteResolver();
+    const footNoteResolver = new footnote_resolver_1.FootnoteResolver();
     const nodes = new parser_1.Parser(tokens, footNoteResolver).parse();
-    return new react_2.default(footNoteResolver, options).render(nodes);
+    return new react_2.ReactRenderer(footNoteResolver, options).render(nodes);
 }
 /**
  * A React commponent that renders Markdown content.
@@ -50,7 +50,7 @@ function convertMarkdownToReactNode(input, options = {
 const MarkdownComponent = ({ content, className, options }) => {
     const rendered = react_1.default.useMemo(() => {
         return convertMarkdownToReactNode(content, options);
-    }, [content, options]);
+    }, [content]);
     return react_1.default.createElement("div", { className }, rendered);
 };
 exports.MarkdownComponent = MarkdownComponent;

package/dist/renderers/default/handler.d.ts

@@ -0,0 +1,21 @@
+import { RenderStrategy } from "../../types/renderer";
+export declare const DocumentHandler: RenderStrategy<string>;
+export declare const ParagraphHandler: RenderStrategy<string>;
+export declare const CodeBlockHandler: RenderStrategy<string>;
+export declare const HeaderHandler: RenderStrategy<string>;
+export declare const QuoteHandler: RenderStrategy<string>;
+export declare const ListHandler: RenderStrategy<string>;
+export declare const ListItemHandler: RenderStrategy<string>;
+export declare const TaskItemHandler: RenderStrategy<string>;
+export declare const BoldHandler: RenderStrategy<string>;
+export declare const ItalicHandler: RenderStrategy<string>;
+export declare const StrikethroughHandler: RenderStrategy<string>;
+export declare const InlineCodeHandler: RenderStrategy<string>;
+export declare const LinkHandler: RenderStrategy<string>;
+export declare const ImageHandler: RenderStrategy<string>;
+export declare const HorizontalLineHandler: RenderStrategy<string>;
+export declare const TextHandler: RenderStrategy<string>;
+export declare const TableHandler: RenderStrategy<string>;
+export declare const HTMLBlockHandler: RenderStrategy<string>;
+export declare const HTMLInlineHandler: RenderStrategy<string>;
+export declare const FootnoteRefHandler: RenderStrategy<string>;