@rokelamen/md2html 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,50 +1,107 @@
-#!/usr/bin/env node
-import { program } from 'commander';
-import * as fs from 'fs';
+const headerReg = /^\s*(#{1,6})(?:\s+|$)(.*)$/;
+
+/**
+ * Since AST-based parsing is too complex and not
+ * suitable for a personal typescript learning project,
+ * So I just let my markdown rendering engine to
+ * receive a line and analysis which type it is,
+ * and then output the corresponding format(with tags).
+ * That means it's just a simple line-by-line parsing.
+ *
+ * Some special scenes still need to be handled carefully:
+ * plain text -> <p>plain text</p>
+ * need to consider whether there is a following empty line.
+ * Cause
+ * ```
+ * plain text 1
+ * plain text 2
+ * ```
+ * is one paragraph NOT two.
+ * The same happens with quote text:
+ * ```
+ * > quote text
+ * plain text
+ * ```
+ * is one paragraph as well.
+ */
 /* The main parse logic */
-function parse(content) {
-    const transform = content.trim();
-    return `<p>${transform}</p>`;
+function parse(markdown) {
+    /* Split markdown content to many lines */
+    const crlfReg = /\r?\n/;
+    const lines = markdown.split(crlfReg);
+    // console.log(lines);
+    const mdBlocks = parseToBlocks(lines);
+    // console.log(mdBlocks);
+    const html = handleTags(mdBlocks);
+    return html;
 }
-// Import these from package.json in the future
-const name = 'md2html';
-const version = '0.1.1';
-const description = 'A simple tool to convert markdown content to html';
-/* Command-line tool logic */
-function command() {
-    /* Set basic info */
-    program
-        .name(name)
-        .version(version)
-        .description(description);
-    /* Config arguments info */
-    program
-        .option('-f, --file <path>', 'source file path')
-        .argument('[input]', 'input content');
-    /* Parse the cli options */
-    program.parse(process.argv);
-    /* Validation check */
-    const options = program.opts();
-    const input = program.args[0];
-    const hasFile = typeof options.file === 'string';
-    const hasInput = typeof input === 'string';
-    // XOR validation
-    if (hasFile === hasInput) {
-        console.error('error: exactly one content source must be provided (either <input> or -f, --file).');
-        process.exit(1);
-    }
-    /* Define one-source content */
-    const content = hasFile
-        ? (() => {
-            try {
-                return fs.readFileSync(options.file, 'utf-8');
-            }
-            catch {
-                console.error(`error: failed to read file "${options.file}"`);
-                process.exit(1);
+/**
+ * Traverse lines to turn to blocks with different types
+ */
+function parseToBlocks(lines) {
+    let lastTextQuoteBlock = { content: '', type: 'text' };
+    let pushed = true;
+    const mdBlocks = [];
+    for (const line of lines) {
+        // Empty line
+        if (!Boolean(line.trim())) {
+            if (!pushed) {
+                mdBlocks.push(lastTextQuoteBlock);
+                pushed = true;
             }
-        })()
-        : input;
-    console.log(parse(content));
+            continue;
+        }
+        // Header
+        const headerM = line.match(headerReg);
+        if (headerM) {
+            mdBlocks.push({
+                type: 'header',
+                level: headerM[1].length,
+                content: headerM[2].trim()
+            });
+            continue;
+        }
+        // Fall back to plain text
+        if (!pushed) {
+            /* last line is also text */
+            lastTextQuoteBlock.content += ' ' + line.trim();
+        }
+        else {
+            lastTextQuoteBlock = {
+                type: 'text',
+                content: line.trim()
+            };
+            pushed = false;
+        }
+    }
+    // Avoid the last block is omitted
+    if (!pushed) {
+        mdBlocks.push(lastTextQuoteBlock);
+        pushed = true;
+    }
+    return mdBlocks;
+}
+/* traverse markdown content blocks and wrap text with tags at proper positions. */
+function handleTags(mdBlocks) {
+    let result = '';
+    for (const block of mdBlocks) {
+        const type = block.type;
+        const content = tagSwtich(block);
+        switch (type) {
+            case "text":
+                result += `<p>${content}</p>` +
+                    '\n';
+                break;
+            case "header":
+                result += `<h${block.level}>${content}</h${block.level}>` +
+                    '\n';
+                break;
+        }
+    }
+    return result;
+}
+function tagSwtich(block) {
+    return block.content;
 }
-command();
+
+export { parse };

package/package.json

@@ -1,20 +1,28 @@
 {
   "name": "@rokelamen/md2html",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "A simple tool to convert markdown content to html",
   "author": "rokelamen <rogerskelamen@gmail.com>",
   "license": "MIT",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
   "bin": {
-    "md2html": "./dist/index.js"
+    "md2html": "./bin/cli.cjs"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
   "scripts": {
-    "clean": "rimraf dist",
-    "build": "npm run clean && tsc",
+    "clean": "rimraf bin dist",
+    "build": "npm run clean && rollup -c rollup.config.ts --configPlugin typescript",
+    "test": "node bin/cli.cjs",
     "prepublishOnly": "npm run build"
   },
   "files": [
+    "bin",
     "dist"
   ],
   "keywords": [
@@ -23,12 +31,16 @@
     "md2html"
   ],
   "devDependencies": {
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@types/commander": "^2.12.0",
     "@types/node": "^25.0.3",
+    "commander": "^14.0.2",
     "rimraf": "^6.1.2",
+    "rollup": "^4.54.0",
+    "tslib": "^2.8.1",
     "typescript": "^5.9.3"
-  },
-  "dependencies": {
-    "commander": "^14.0.2"
   }
 }