@jianwen-lang/parser 0.1.1 → 0.1.2

package/dist/core/block/rules/table.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseTableBlock = tryParseTableBlock;
+const diagnostics_1 = require("../../diagnostics");
+const location_1 = require("../../location");
+const lexer_1 = require("../../../lexer/lexer");
+const attribute_line_1 = require("./attribute-line");
+function tryParseTableBlock(ctx) {
+    if (!ctx.pending.isSheet || !isTableRow(ctx.lineInfo.content)) {
+        return null;
+    }
+    const rawLines = [ctx.lineInfo.raw];
+    const rowContents = [
+        { text: ctx.lineInfo.content, raw: ctx.lineInfo.raw, line: ctx.index + 1 },
+    ];
+    let jTable = ctx.index + 1;
+    while (jTable < ctx.lines.length) {
+        const nextRaw = ctx.lines[jTable];
+        if (nextRaw === undefined) {
+            jTable += 1;
+            continue;
+        }
+        const nextInfo = (0, lexer_1.getLineInfo)(nextRaw);
+        const nextTrimmed = nextInfo.content.trim();
+        if (nextTrimmed.length === 0) {
+            break;
+        }
+        if ((0, attribute_line_1.isAttributeOnlyLine)(nextTrimmed)) {
+            break;
+        }
+        if (!isTableRow(nextInfo.content)) {
+            break;
+        }
+        rawLines.push(nextInfo.raw);
+        rowContents.push({ text: nextInfo.content, raw: nextInfo.raw, line: jTable + 1 });
+        jTable += 1;
+    }
+    const { rows, align } = parseTableRows(rowContents, ctx.errors);
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    let tableAlign = align;
+    if (!tableAlign && blockAttrs?.align && blockAttrs.align !== 'left') {
+        const columnCount = getMaxTableColumnCount(rows);
+        if (columnCount > 0) {
+            tableAlign = Array.from({ length: columnCount }, () => blockAttrs.align);
+        }
+    }
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: rawLines.join('\n'),
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.lineLocation);
+        block = disabled;
+    }
+    else {
+        const tableBlock = {
+            type: 'table',
+            rows,
+            align: tableAlign,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(tableBlock, ctx.lineLocation);
+        block = tableBlock;
+    }
+    ctx.commitBlock(block, blockAttrs);
+    return jTable;
+}
+function isTableRow(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('|')) {
+        return false;
+    }
+    return trimmed.indexOf('|', 1) !== -1;
+}
+function parseTableRows(lines, errors) {
+    if (lines.length === 0) {
+        return { rows: [], align: undefined };
+    }
+    for (const line of lines) {
+        const trimmed = line.text.trim();
+        if (isTableRow(trimmed) && !trimmed.endsWith('|')) {
+            const contentStart = line.raw.length - line.text.length;
+            const trimmedContent = line.text.replace(/\s+$/, '');
+            const column = contentStart + trimmedContent.length + 1;
+            (0, diagnostics_1.reportParseError)(errors, {
+                message: 'Table row is missing closing "|" border',
+                line: line.line,
+                column,
+            });
+        }
+    }
+    const remaining = [...lines];
+    let align;
+    const firstLine = remaining[0];
+    if (firstLine !== undefined) {
+        const firstTrimmed = firstLine.text.trim();
+        if (isAlignmentRow(firstTrimmed)) {
+            align = parseAlignmentLine(firstTrimmed);
+            remaining.shift();
+        }
+    }
+    if (align === undefined && remaining.length >= 2) {
+        const secondLine = remaining[1];
+        if (secondLine !== undefined) {
+            const secondTrimmed = secondLine.text.trim();
+            if (isAlignmentRow(secondTrimmed)) {
+                align = parseAlignmentLine(secondTrimmed);
+                remaining.splice(1, 1);
+            }
+        }
+    }
+    const rows = [];
+    for (const line of remaining) {
+        const trimmed = line.text.trim();
+        if (!isTableRow(trimmed)) {
+            continue;
+        }
+        const rawCells = trimmed.split('|').slice(1, -1);
+        const cells = [];
+        for (let ci = 0; ci < rawCells.length; ci += 1) {
+            const rawCell = rawCells[ci];
+            if (rawCell === undefined) {
+                continue;
+            }
+            let cellText = rawCell.trim();
+            let cellAlign;
+            if (cellText.startsWith('[r]')) {
+                cellAlign = 'right';
+                cellText = cellText.slice(3).trim();
+            }
+            else if (cellText.startsWith('[c]')) {
+                cellAlign = 'center';
+                cellText = cellText.slice(3).trim();
+            }
+            else if (align && ci < align.length) {
+                cellAlign = align[ci];
+            }
+            const cell = {
+                type: 'tableCell',
+                children: cellText.length > 0 ? [{ type: 'text', value: cellText }] : [],
+                align: cellAlign,
+            };
+            (0, location_1.setNodeLocation)(cell, { line: line.line, column: 1 });
+            cells.push(cell);
+        }
+        const row = {
+            type: 'tableRow',
+            cells,
+        };
+        rows.push(row);
+    }
+    return { rows, align };
+}
+function isAlignmentRow(trimmed) {
+    if (!isTableRow(trimmed)) {
+        return false;
+    }
+    const segments = trimmed.split('|').slice(1, -1);
+    if (segments.length === 0) {
+        return false;
+    }
+    for (const seg of segments) {
+        const t = seg.trim();
+        if (!/^:?-+:?$/.test(t)) {
+            return false;
+        }
+    }
+    return true;
+}
+function parseAlignmentLine(trimmed) {
+    const segments = trimmed.split('|').slice(1, -1);
+    const result = [];
+    for (const seg of segments) {
+        const t = seg.trim();
+        const left = t.startsWith(':');
+        const right = t.endsWith(':');
+        if (left && right) {
+            result.push('center');
+        }
+        else if (right) {
+            result.push('right');
+        }
+        else {
+            result.push('left');
+        }
+    }
+    return result;
+}
+function getMaxTableColumnCount(rows) {
+    let max = 0;
+    for (const row of rows) {
+        if (row.cells.length > max) {
+            max = row.cells.length;
+        }
+    }
+    return max;
+}

package/dist/core/block/runtime.d.ts

@@ -0,0 +1,25 @@
+import { BlockAttributes, BlockNode } from '../ast';
+import { SourceLocation } from '../location';
+import { CommitBlockOptions } from './rules/types';
+import { PendingBlockContext } from './types';
+interface LineInfoLike {
+    tabCount: number;
+}
+export interface BlockParseRuntime {
+    pending: PendingBlockContext;
+    lastBlockPosition: BlockAttributes['position'];
+}
+interface CommitParsedBlockParams {
+    runtime: BlockParseRuntime;
+    blocks: BlockNode[];
+    block: BlockNode;
+    blockAttrs: BlockAttributes | undefined;
+    lineInfo: LineInfoLike;
+    lineLocation: SourceLocation;
+    options?: CommitBlockOptions;
+}
+export declare function createBlockParseRuntime(): BlockParseRuntime;
+export declare function buildBlockAttrs(runtime: BlockParseRuntime, tabCount: number): BlockAttributes | undefined;
+export declare function resetPending(pending: PendingBlockContext): void;
+export declare function commitParsedBlock(params: CommitParsedBlockParams): void;
+export {};

package/dist/core/block/runtime.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBlockParseRuntime = createBlockParseRuntime;
+exports.buildBlockAttrs = buildBlockAttrs;
+exports.resetPending = resetPending;
+exports.commitParsedBlock = commitParsedBlock;
+const location_1 = require("../location");
+function createBlockParseRuntime() {
+    return {
+        pending: {
+            attrs: undefined,
+            foldNext: false,
+            tagName: undefined,
+            isComment: false,
+            isDisabled: false,
+            isSheet: false,
+            isHtml: false,
+        },
+        lastBlockPosition: 'L',
+    };
+}
+function buildBlockAttrs(runtime, tabCount) {
+    const baseAttrs = runtime.pending.attrs ? { ...runtime.pending.attrs } : undefined;
+    const positionFromTabs = mapTabsToPosition(tabCount);
+    let blockAttrs = baseAttrs;
+    if (positionFromTabs) {
+        if (!blockAttrs) {
+            blockAttrs = {};
+        }
+        if (!blockAttrs.position) {
+            blockAttrs.position = positionFromTabs;
+        }
+    }
+    if (runtime.pending.foldNext) {
+        if (!blockAttrs) {
+            blockAttrs = {};
+        }
+        blockAttrs.fold = true;
+    }
+    return blockAttrs;
+}
+function resetPending(pending) {
+    pending.attrs = undefined;
+    pending.foldNext = false;
+    pending.tagName = undefined;
+    pending.isComment = false;
+    pending.isDisabled = false;
+    pending.isSheet = false;
+    pending.isHtml = false;
+}
+function commitParsedBlock(params) {
+    const { runtime, blocks, block, blockAttrs, lineInfo, lineLocation, options } = params;
+    const allowTag = options?.allowTag !== false;
+    const taggedOrOriginal = allowTag
+        ? wrapTaggedIfNeeded(block, runtime.pending, blockAttrs, lineLocation)
+        : block;
+    const finalBlock = wrapCommentIfNeeded(taggedOrOriginal, runtime.pending, lineLocation);
+    blocks.push(finalBlock);
+    runtime.lastBlockPosition = resolveNextPosition(getBlockAttributes(finalBlock), lineInfo.tabCount, runtime.lastBlockPosition);
+    resetPending(runtime.pending);
+    options?.postResetPending?.(runtime.pending);
+}
+function wrapTaggedIfNeeded(block, pending, blockAttrs, lineLocation) {
+    if (!pending.tagName) {
+        return block;
+    }
+    const tagged = {
+        type: 'taggedBlock',
+        name: pending.tagName,
+        child: block,
+        blockAttrs,
+    };
+    (0, location_1.setNodeLocation)(tagged, lineLocation);
+    return tagged;
+}
+function wrapCommentIfNeeded(block, pending, lineLocation) {
+    if (!pending.isComment) {
+        return block;
+    }
+    const comment = {
+        type: 'commentBlock',
+        children: [block],
+        blockAttrs: undefined,
+    };
+    (0, location_1.setNodeLocation)(comment, lineLocation);
+    return comment;
+}
+function getBlockAttributes(block) {
+    if ('blockAttrs' in block) {
+        const candidate = block.blockAttrs;
+        return candidate;
+    }
+    return undefined;
+}
+function resolveNextPosition(attrs, tabCount, fallback) {
+    if (attrs?.position) {
+        return attrs.position;
+    }
+    const tabPosition = mapTabsToPosition(tabCount);
+    if (tabPosition) {
+        return tabPosition;
+    }
+    return fallback;
+}
+function mapTabsToPosition(tabCount) {
+    if (tabCount === 0) {
+        return 'L';
+    }
+    if (tabCount === 1) {
+        return 'C';
+    }
+    if (tabCount >= 2) {
+        return 'R';
+    }
+    return undefined;
+}