markdown-it-adv-table 0.1.0

package/dist/table.js

@@ -0,0 +1,387 @@
+import { Lexer, unwrapLiteral } from "./lexer.js";
+/**
+ * TableSpec keeps table attributes
+ */
+export class TableSpec {
+    attr;
+    styles;
+    headerRows;
+    headerCols;
+    colspecs;
+    constructor(attr) {
+        this.attr = attr;
+        this.headerRows = parseInt(attr["header-rows"] ?? "0");
+        this.headerCols = parseInt(attr["header-columns"] ?? "0");
+        this.colspecs = new ColSpecs(attr.cols ?? "");
+        this.styles = TableSpec.parseStyle(attr.style ?? "");
+    }
+    get numCols() {
+        return this.colspecs.numCols;
+    }
+    static parseStyle(style) {
+        return style.split(",").map((s) => s.trim());
+    }
+    static parseInfoString(info) {
+        const lexer = new Lexer(info);
+        const tokens = [];
+        const wordRe = /^[a-zA-Z][a-zA-Z0-9_\-]+/;
+        const result = {};
+        let cp = 0;
+        while (cp != Lexer.EOF) {
+            lexer.skipWhitespace();
+            cp = lexer.peek();
+            if (Lexer.isAlphabet(cp)) {
+                tokens.push(lexer.consumeRe(wordRe));
+            }
+            else if (Lexer.cmp(cp, "\"")) {
+                tokens.push(lexer.consumeLiteral("\""));
+            }
+            else if (Lexer.cmp(cp, "=")) {
+                tokens.push(lexer.consume());
+            }
+            else if (Lexer.isEOF(cp)) {
+                break;
+            }
+            else {
+                // unknown symbol?
+                tokens.push(lexer.consume());
+            }
+        }
+        ;
+        const pairedKeys = TableSpec.awareKeys();
+        let lc = 0;
+        while (tokens[lc] !== undefined) {
+            const token = tokens[lc];
+            if (pairedKeys.includes(token)) {
+                const key = consume();
+                consume("=");
+                const value = consume();
+                result[key] = value;
+            }
+            else {
+                // ignore unknown token
+                consume();
+            }
+        }
+        return result;
+        /** consume one token from token stream */
+        function consume(text) {
+            const token = tokens[lc];
+            if (text && token !== text) {
+                throw new Error(`parse error: expected ${text} but found ${token}`);
+            }
+            lc++;
+            return token;
+        }
+    }
+    static awareKeys() {
+        const k = {
+            cols: "",
+            align: "",
+            "header-columns": "",
+            "header-rows": "",
+            style: "",
+            format: ""
+        };
+        return Object.keys(k);
+    }
+}
+/**
+ * ColSpecs keeps all column specifications
+ */
+export class ColSpecs {
+    numCols;
+    specs;
+    constructor(colspec) {
+        if (colspec.startsWith("\"") || colspec.includes(",")) {
+            // colspec must be "1,1,1" not 1,1,1
+            // we can try parse 1,1,1 .... but since this is an invalid syntax, 
+            // the parser won't recognize unwrapped commma-separated values.
+            const specs = unwrapLiteral(colspec, "\"").split(",");
+            this.numCols = Math.max(1, specs.length);
+            this.specs = specs.map(ColSpecs.parseColSpec);
+        }
+        else if (/^\d+/.test(colspec)) {
+            this.numCols = Math.max(1, parseInt(colspec, 10));
+            this.specs = Array(this.numCols).fill({});
+        }
+        else {
+            this.numCols = 0;
+            this.specs = Array(this.numCols).fill({});
+        }
+    }
+    colSpec(col) {
+        return this.specs[col] || {};
+    }
+    colWidth(col) {
+        const spec = this.colSpec(col);
+        if (spec.width) {
+            return parseInt(spec.width, 10);
+        }
+        return 1;
+    }
+    colWidthRatio(col) {
+        let totalWidth = 0;
+        for (let c = 0; c < this.numCols; c++) {
+            totalWidth += this.colWidth(c);
+        }
+        return this.colWidth(col) / totalWidth;
+    }
+    /** Forcefully re-initailize this instance. */
+    lazyInit(cols) {
+        this.numCols = cols;
+        this.specs = Array(cols).fill({});
+    }
+    /** Parse colspec for single column */
+    static parseColSpec(spec) {
+        let pos = 0;
+        const attr = {};
+        while (pos < spec.length) {
+            const char = spec[pos];
+            if (char === "^") {
+                consume();
+                attr.align = "center";
+            }
+            else if (char === "<") {
+                consume();
+                attr.align = "left";
+            }
+            else if (char === ">") {
+                consume();
+                attr.align = "right";
+            }
+            else if (char >= "0" && char <= "9") {
+                attr.width = consumeNumber();
+                break;
+            }
+            else {
+                consume();
+            }
+        }
+        return attr;
+        function consume() {
+            return spec[pos++];
+        }
+        function consumeNumber() {
+            const match = spec.slice(pos).match(/^\d+/);
+            if (!match)
+                throw new Error("cannot consume number");
+            return match[0];
+        }
+    }
+}
+export class TableCell {
+    row;
+    col;
+    attr;
+    constructor(row, col, attr) {
+        this.row = row;
+        this.col = col;
+        this.attr = attr;
+    }
+    get colspan() {
+        return this.attr.colspan || 1;
+    }
+    get rowspan() {
+        return this.attr.rowspan || 1;
+    }
+    is(row, col) {
+        return this.row === row && this.col === col;
+    }
+    isIn(row, col, rspan, cspan) {
+        return (this.row <= row && this.row + this.rowspan > row &&
+            this.col <= col && this.col + this.colspan > col);
+    }
+    contains(row, col) {
+        return (this.row <= row && this.row + this.rowspan > row &&
+            this.col <= col && this.col + this.colspan > col);
+    }
+}
+/**
+ * A state machine to track cell position and its attributes
+ */
+export class CellState {
+    static _initialPos = [-1, -1];
+    _tableSpec;
+    _pos;
+    _cells;
+    constructor(tableSpec) {
+        this._tableSpec = tableSpec;
+        this._pos = [...CellState._initialPos];
+        this._cells = [];
+    }
+    get numCols() {
+        return this._tableSpec.numCols;
+    }
+    get pos() {
+        return this._pos;
+    }
+    get row() {
+        return this._pos[0];
+    }
+    set row(num) {
+        this._pos[0] = num;
+    }
+    get col() {
+        return this._pos[1];
+    }
+    set col(num) {
+        this._pos[1] = num;
+    }
+    /** Starting from the top-left cell, find the next free cell. **/
+    next() {
+        if (this.row === -1) {
+            this.row = 0;
+            this.col = 0;
+        }
+        else {
+            do {
+                this.col++;
+                if (this.col >= this.numCols) {
+                    this.col = 0;
+                    this.row++;
+                }
+            } while (this.isSpanned(this.row, this.col));
+        }
+        return {
+            row: this.row,
+            col: this.col,
+        };
+    }
+    /**
+     * Get cell attribute. If the cell is spanned by the other, it will return
+     * the belonging cell. Returns undefined if no attribute is set.
+     */
+    get(row, col) {
+        for (const span of this._cells) {
+            if (span.contains(row, col)) {
+                return span;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Set cell attribute. If the cell is already spanned by the other,
+     * it will update the belonging cell. Modifying the span size will
+     * wipe attributes from the cells being affected.
+     */
+    set(row, col, attr) {
+        for (const span of this._cells) {
+            if (span.contains(row, col)) {
+                Object.assign(span.attr, attr);
+                this.wipe(span.row, span.col, span.rowspan, span.colspan, true);
+                return;
+            }
+        }
+        this._cells.push(new TableCell(row, col, attr));
+    }
+    wipe(row, col, rowspan, colspan, keepOrigin = false) {
+        this._cells = this._cells.filter(c => {
+            return keepOrigin
+                ? c.isIn(row, col, rowspan, colspan) && !c.is(row, col)
+                : c.isIn(row, col, rowspan, colspan);
+        });
+    }
+    /** Return true if this cell is spanned (includes self spanning) */
+    isSpanned(row, col) {
+        for (const span of this._cells) {
+            if (!span.is(row, col) && span.contains(row, col)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Return the cell which covers the given cell (excludes self span)*/
+    spannedBy(row, col) {
+        for (const span of this._cells) {
+            if (!span.is(row, col) && span.contains(row, col)) {
+                return span;
+            }
+        }
+        return undefined;
+    }
+    /** Return true if this cell is the left most cell **/
+    isLeftMost(row, col) {
+        if (col <= 0) {
+            return true; // left most, or out of range
+        }
+        else {
+            const span = this.get(row, col);
+            return span !== undefined && span.col === 0;
+        }
+    }
+    isRightMost(row, col) {
+        if (col >= this.numCols - 1) {
+            return true; // right most, or out of range
+        }
+        else {
+            const span = this.get(row, col);
+            return span !== undefined && (span.col + span.colspan) === this.numCols;
+        }
+    }
+    isRowFirst(row, col) {
+        if (col < 0)
+            return false;
+        if (col === 0) {
+            // If this cell is spanned by the other cell, it is not a row starter
+            return this.spannedBy(row, col) === undefined;
+        }
+        // if this cell is spanned by the other cell, 
+        // always return false. 
+        if (this.spannedBy(row, col) !== undefined) {
+            return false;
+        }
+        while (col > 0) {
+            const span = this.spannedBy(row, col - 1);
+            // recursively check left cell
+            if (span !== undefined) {
+                if (span.col < col) {
+                    if (span.row === row) {
+                        return false; // spanning cell is in the same row
+                    }
+                    else {
+                        col = span.col;
+                    }
+                }
+                else {
+                    throw new Error("never happen. check implementation");
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        // all cells in left are spanned, so this cell is the row-first cell
+        return true;
+    }
+    isRowLast(row, col) {
+        if (col >= this.numCols)
+            return false;
+        if (col === this.numCols - 1) {
+            // If this cell is spanned by the other cell, it is not a row closer.
+            return this.spannedBy(row, col) === undefined;
+        }
+        // if this cell is spanned by the other cell, 
+        // always return false. 
+        if (this.spannedBy(row, col) !== undefined) {
+            return false;
+        }
+        while (col < this.numCols - 1) {
+            const span = this.spannedBy(row, col + 1);
+            // recursively check right cell
+            if (span !== undefined) {
+                if (span.col + span.rowspan > col) {
+                    col = span.col + span.rowspan;
+                }
+                else {
+                    throw new Error("never happen. check implementation");
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        // all cells in right are spanned, so this cell is the row-last cell
+        return true;
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends object ? T[P] extends Function ? T[P] : DeepPartial<T[P]> : T[P];
+};
+export declare function deepmerge<T, U>(target: Partial<T>, source?: Partial<U>): T & U;

package/dist/utils.js

@@ -0,0 +1,47 @@
+function isPrimitive(value) {
+    return (value === null
+        || typeof value === "string"
+        || typeof value === "number"
+        || typeof value === "boolean"
+        || typeof value === "symbol"
+        || typeof value === "bigint"
+        || typeof value === "undefined");
+}
+function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === "[object Object]"
+        && Object.getPrototypeOf(obj) === Object.prototype;
+}
+export function deepmerge(target, source) {
+    const seen = new WeakSet();
+    function merge(target, source) {
+        if (seen.has(source)) {
+            return undefined;
+        }
+        if (isPrimitive(source)) {
+            return source;
+        }
+        if (Array.isArray(source)) {
+            seen.add(source);
+            return source.map(item => merge(undefined, item));
+        }
+        if (isPlainObject(source)) {
+            seen.add(source);
+            const result = isPlainObject(target) ? { ...target } : {};
+            for (const key of Object.keys(source)) {
+                // Skip dangerous keys
+                if (key === "__proto__" || key === "constructor" || key === "prototype") {
+                    continue;
+                }
+                const value = source[key];
+                const merged = merge(result[key], value);
+                if (merged !== undefined) {
+                    result[key] = merged;
+                }
+            }
+            return result;
+        }
+        return undefined;
+    }
+    return merge(target, source);
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "markdown-it-adv-table",
+  "version": "0.1.0",
+  "description": "Markdown syntax extension for better table support",
+  "keywords": [
+    "markdown",
+    "markdown-it",
+    "markdown-it-plugin",
+    "table",
+    "csv"
+  ],
+  "homepage": "https://github.com/yamavol/markdown-it-adv-table#readme",
+  "bugs": {
+    "url": "https://github.com/yamavol/markdown-it-adv-table/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yamavol/markdown-it-adv-table.git"
+  },
+  "license": "MIT",
+  "author": "yamavol",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "directories": {
+    "doc": "docs",
+    "test": "test"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:dist": "tsc --build tsconfig.dist.json",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix"
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^4.2.0",
+    "@types/markdown-it": "^14.1.2",
+    "@types/node": "^22.14.1",
+    "@vitest/coverage-v8": "^3.1.1",
+    "eslint": "^9.24.0",
+    "eslint-plugin-import": "^2.31.0",
+    "markdown-it": "^14.1.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.29.1",
+    "vitest": "^3.1.1"
+  }
+}