@jianwen-lang/parser 0.1.1 → 0.1.2

package/dist/html/convert.d.ts

@@ -1,6 +1,7 @@
 import { ParseOptions } from '../core/parser';
 import { JianwenDocument } from '../core/ast';
 import { ParseError } from '../core/errors';
+import { RenderedBlockGroup } from './render/html';
 import { RenderHtmlOptions } from './render/utils';
 export declare const DEFAULT_RUNTIME_SRC = "dist/html/theme/runtime.js";
 export interface HtmlDocumentOptions {
@@ -25,5 +26,12 @@ export interface RenderJianwenToHtmlDocumentResult {
     ast: JianwenDocument;
     errors: ParseError[];
 }
+export interface RenderJianwenToHtmlDocumentWithBlockMapResult {
+    html: string;
+    ast: JianwenDocument;
+    errors: ParseError[];
+    groups: RenderedBlockGroup[];
+}
 export declare function buildHtmlDocument(bodyHtml: string, options?: HtmlDocumentOptions): string;
 export declare function renderJianwenToHtmlDocument(source: string, options?: RenderJianwenToHtmlDocumentOptions): RenderJianwenToHtmlDocumentResult;
+export declare function renderJianwenToHtmlDocumentWithBlockMap(source: string, options?: RenderJianwenToHtmlDocumentOptions): RenderJianwenToHtmlDocumentWithBlockMapResult;

package/dist/html/convert.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_RUNTIME_SRC = void 0;
 exports.buildHtmlDocument = buildHtmlDocument;
 exports.renderJianwenToHtmlDocument = renderJianwenToHtmlDocument;
+exports.renderJianwenToHtmlDocumentWithBlockMap = renderJianwenToHtmlDocumentWithBlockMap;
 const parser_1 = require("../core/parser");
 const format_1 = require("./format");
 const html_1 = require("./render/html");
@@ -59,3 +60,24 @@ function renderJianwenToHtmlDocument(source, options = {}) {
     });
     return { html, ast: parseResult.ast, errors: parseResult.errors };
 }
+function renderJianwenToHtmlDocumentWithBlockMap(source, options = {}) {
+    const parseResult = (0, parser_1.parseJianwenWithErrors)(source, options.parse);
+    const renderOptions = {
+        includeMeta: true,
+        includeComments: false,
+        emitBlockMeta: true,
+        ...options.render,
+    };
+    const rendered = (0, html_1.renderDocumentToHtmlWithBlockMap)(parseResult.ast, renderOptions);
+    const title = options.document?.title ?? parseResult.ast.meta?.title;
+    const html = buildHtmlDocument(rendered.html, {
+        ...options.document,
+        title,
+    });
+    return {
+        html,
+        ast: parseResult.ast,
+        errors: parseResult.errors,
+        groups: rendered.groups,
+    };
+}

package/dist/html/render/blocks.d.ts

@@ -1,4 +1,19 @@
 import { BlockNode } from '../../core/ast';
 import { RenderHtmlOptions } from './utils';
+export type RenderBlockGroupKind = 'single' | 'sameLine' | 'foldable';
+export interface RenderBlockGroupDraft {
+    id: string;
+    kind: RenderBlockGroupKind;
+    startBlockIndex: number;
+    endBlockIndex: number;
+    startLine?: number;
+    origin?: string;
+    readOnly: boolean;
+}
+export interface RenderBlocksResult {
+    html: string;
+    groups: RenderBlockGroupDraft[];
+}
 export declare function renderBlocksToHtml(blocks: BlockNode[], options?: RenderHtmlOptions): string;
+export declare function renderBlocksToHtmlWithGroups(blocks: BlockNode[], options?: RenderHtmlOptions): RenderBlocksResult;
 export declare function renderBlockToHtml(block: BlockNode, options: RenderHtmlOptions): string;

package/dist/html/render/blocks.js

@@ -1,18 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderBlocksToHtml = renderBlocksToHtml;
+exports.renderBlocksToHtmlWithGroups = renderBlocksToHtmlWithGroups;
 exports.renderBlockToHtml = renderBlockToHtml;
 const utils_1 = require("./utils");
 const inlines_1 = require("./inlines");
+const location_1 = require("../../core/location");
 function renderBlocksToHtml(blocks, options = {}) {
+    return renderBlocksToHtmlWithGroups(blocks, options).html;
+}
+function renderBlocksToHtmlWithGroups(blocks, options = {}) {
     const result = [];
+    const groups = [];
     let i = 0;
-    function wrapBlock(html) {
+    function buildGroupDraft(kind, blockList, startBlockIndex) {
+        const endBlockIndex = startBlockIndex + blockList.length - 1;
+        let startLine;
+        const origins = new Set();
+        for (const block of blockList) {
+            const location = (0, location_1.getNodeLocation)(block);
+            if (location && (startLine === undefined || location.line < startLine)) {
+                startLine = location.line;
+            }
+            const origin = (0, location_1.getNodeOrigin)(block);
+            if (origin) {
+                origins.add(origin);
+            }
+        }
+        const origin = origins.size === 1 ? Array.from(origins)[0] : undefined;
+        const hasIncludeBlock = blockList.some((block) => block.type === 'include');
+        const readOnly = origins.size > 0 || hasIncludeBlock;
+        return {
+            id: `g-${groups.length}`,
+            kind,
+            startBlockIndex,
+            endBlockIndex,
+            startLine,
+            origin,
+            readOnly,
+        };
+    }
+    function wrapBlock(html, group) {
         if (!html || !html.trim())
             return '';
         if (options.suppressBlockWrapper)
             return html;
-        return `<div class="jw-block">${html}</div>`;
+        const dataAttr = options.emitBlockMeta && group ? ` data-jw-group-id="${(0, utils_1.escapeAttr)(group.id)}"` : '';
+        return `<div class="jw-block"${dataAttr}>${html}</div>`;
     }
     while (i < blocks.length) {
         const block = blocks[i];
@@ -41,13 +75,18 @@ function renderBlocksToHtml(blocks, options = {}) {
             }
             const detailsContent = foldedBlocks.join('');
             const detailsHtml = `<details class="jw-foldable-section">${headingHtml}${detailsContent}</details>`;
-            result.push(wrapBlock(detailsHtml));
+            const groupBlocks = blocks.slice(i, j).filter((item) => Boolean(item));
+            const group = buildGroupDraft('foldable', groupBlocks, i);
+            groups.push(group);
+            result.push(wrapBlock(detailsHtml, group));
             i = j;
             continue;
         }
         const blockAttrs = 'blockAttrs' in block ? block.blockAttrs : undefined;
         if (!blockAttrs?.sameLine) {
-            result.push(wrapBlock(renderBlockToHtml(block, options)));
+            const group = buildGroupDraft('single', [block], i);
+            groups.push(group);
+            result.push(wrapBlock(renderBlockToHtml(block, options), group));
             i++;
             continue;
         }
@@ -81,10 +120,15 @@ function renderBlocksToHtml(blocks, options = {}) {
             }
         }
         const rowHtml = rowBlocks.map((b) => renderBlockToHtml(b, options)).join('');
-        result.push(wrapBlock(`<div class="jw-same-line-row">${rowHtml}</div>`));
+        const group = buildGroupDraft('sameLine', rowBlocks, rowStartIndex);
+        groups.push(group);
+        result.push(wrapBlock(`<div class="jw-same-line-row">${rowHtml}</div>`, group));
         i = rowStartIndex + rowBlocks.length;
     }
-    return result.join('');
+    return {
+        html: result.join(''),
+        groups,
+    };
 }
 function renderBlockToHtml(block, options) {
     switch (block.type) {

package/dist/html/render/html.d.ts

@@ -3,6 +3,22 @@ import { RenderHtmlOptions } from './utils';
 export { RenderHtmlOptions } from './utils';
 export { DocumentTheme } from '../theme/theme';
 export { renderBlocksToHtml } from './blocks';
+export { renderBlocksToHtmlWithGroups } from './blocks';
 export { renderInlinesToHtml } from './inlines';
+export interface RenderedBlockGroup {
+    id: string;
+    kind: 'single' | 'sameLine' | 'foldable';
+    startBlockIndex: number;
+    endBlockIndex: number;
+    startLine?: number;
+    endLine?: number;
+    origin?: string;
+    readOnly: boolean;
+}
+export interface RenderDocumentWithBlockMapResult {
+    html: string;
+    groups: RenderedBlockGroup[];
+}
 export declare function createDefaultAssetPathResolver(sourceFilePath: string, outputFilePath: string): (assetPath: string) => string | undefined;
 export declare function renderDocumentToHtml(doc: JianwenDocument, options?: RenderHtmlOptions): string;
+export declare function renderDocumentToHtmlWithBlockMap(doc: JianwenDocument, options?: RenderHtmlOptions): RenderDocumentWithBlockMapResult;

package/dist/html/render/html.js

@@ -33,9 +33,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderInlinesToHtml = exports.renderBlocksToHtml = void 0;
+exports.renderInlinesToHtml = exports.renderBlocksToHtmlWithGroups = exports.renderBlocksToHtml = void 0;
 exports.createDefaultAssetPathResolver = createDefaultAssetPathResolver;
 exports.renderDocumentToHtml = renderDocumentToHtml;
+exports.renderDocumentToHtmlWithBlockMap = renderDocumentToHtmlWithBlockMap;
 const path = __importStar(require("path"));
 const format_1 = require("../format");
 const utils_1 = require("./utils");
@@ -43,6 +44,8 @@ const meta_1 = require("./meta");
 const blocks_1 = require("./blocks");
 var blocks_2 = require("./blocks");
 Object.defineProperty(exports, "renderBlocksToHtml", { enumerable: true, get: function () { return blocks_2.renderBlocksToHtml; } });
+var blocks_3 = require("./blocks");
+Object.defineProperty(exports, "renderBlocksToHtmlWithGroups", { enumerable: true, get: function () { return blocks_3.renderBlocksToHtmlWithGroups; } });
 var inlines_1 = require("./inlines");
 Object.defineProperty(exports, "renderInlinesToHtml", { enumerable: true, get: function () { return inlines_1.renderInlinesToHtml; } });
 function createDefaultAssetPathResolver(sourceFilePath, outputFilePath) {
@@ -58,6 +61,25 @@ function createDefaultAssetPathResolver(sourceFilePath, outputFilePath) {
     };
 }
 function renderDocumentToHtml(doc, options = {}) {
+    return renderDocumentToHtmlWithBlockMap(doc, {
+        ...options,
+        emitBlockMeta: options.emitBlockMeta ?? false,
+    }).html;
+}
+function finalizeGroups(groups, sourceLineCount) {
+    return groups.map((group, index) => {
+        const next = groups[index + 1];
+        let endLine = sourceLineCount;
+        if (next?.startLine !== undefined) {
+            endLine = Math.max(1, next.startLine - 1);
+        }
+        return {
+            ...group,
+            endLine: group.startLine !== undefined ? endLine : undefined,
+        };
+    });
+}
+function renderDocumentToHtmlWithBlockMap(doc, options = {}) {
     const wrapperTag = options.documentWrapperTag === undefined ? 'article' : options.documentWrapperTag;
     const finalOptions = { ...options };
     if (options.sourceFilePath && options.outputFilePath && !options.resolveAssetPath) {
@@ -68,22 +90,34 @@ function renderDocumentToHtml(doc, options = {}) {
         innerParts.push((0, meta_1.renderMetaToHtml)(doc.meta));
     }
     if (!wrapperTag) {
-        innerParts.push((0, blocks_1.renderBlocksToHtml)(doc.children, {
+        const rendered = (0, blocks_1.renderBlocksToHtmlWithGroups)(doc.children, {
             ...finalOptions,
             suppressBlockWrapper: true,
-        }));
+            emitBlockMeta: finalOptions.emitBlockMeta ?? true,
+        });
+        const lineCount = doc.source ? doc.source.split('\n').length : undefined;
+        innerParts.push(rendered.html);
+        return {
+            html: innerParts.join(''),
+            groups: finalizeGroups(rendered.groups, lineCount),
+        };
     }
     else {
-        innerParts.push((0, blocks_1.renderBlocksToHtml)(doc.children, finalOptions));
-    }
-    const innerHtml = innerParts.join('');
-    if (!wrapperTag) {
-        return innerHtml;
+        const rendered = (0, blocks_1.renderBlocksToHtmlWithGroups)(doc.children, {
+            ...finalOptions,
+            emitBlockMeta: finalOptions.emitBlockMeta ?? true,
+        });
+        innerParts.push(rendered.html);
+        const innerHtml = innerParts.join('');
+        const wrapperAttrs = (0, meta_1.buildDocumentWrapperAttributes)(doc.meta);
+        const themeAttr = finalOptions.documentTheme
+            ? ` data-jw-theme="${(0, utils_1.escapeAttr)(finalOptions.documentTheme)}"`
+            : '';
+        const html = `<${wrapperTag} class="jw-root"${wrapperAttrs}${themeAttr}>${innerHtml}</${wrapperTag}>`;
+        const lineCount = doc.source ? doc.source.split('\n').length : undefined;
+        return {
+            html: finalOptions.format ? (0, format_1.formatHtml)(html) : html,
+            groups: finalizeGroups(rendered.groups, lineCount),
+        };
     }
-    const wrapperAttrs = (0, meta_1.buildDocumentWrapperAttributes)(doc.meta);
-    const themeAttr = finalOptions.documentTheme
-        ? ` data-jw-theme="${(0, utils_1.escapeAttr)(finalOptions.documentTheme)}"`
-        : '';
-    const html = `<${wrapperTag} class="jw-root"${wrapperAttrs}${themeAttr}>${innerHtml}</${wrapperTag}>`;
-    return finalOptions.format ? (0, format_1.formatHtml)(html) : html;
 }

package/dist/html/render/utils.d.ts

@@ -3,6 +3,7 @@ import { DocumentTheme } from '../theme/theme';
 export interface RenderHtmlOptions {
     includeMeta?: boolean;
     includeComments?: boolean;
+    emitBlockMeta?: boolean;
     resolveHtmlSource?: (source: string) => string | undefined;
     resolveInclude?: (mode: 'file' | 'tag', target: string) => string | undefined;
     resolveAssetPath?: (assetPath: string) => string | undefined;

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@jianwen-lang/parser",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "JianWen language parser implemented in TypeScript",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jianwen-lang/parser.git"
+  },
   "publishConfig": {
     "access": "public"
   },