@markuplint/parser-utils 3.13.0 → 4.0.0-alpha.10

package/lib/ignore-block.js

@@ -1,28 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.restoreNode = exports.ignoreBlock = void 0;
-const const_1 = require("./const");
-const create_token_1 = require("./create-token");
-const get_location_1 = require("./get-location");
-const siblings_correction_1 = require("./siblings-correction");
-function ignoreBlock(source, tags, maskChar = const_1.MASK_CHAR) {
+import { MASK_CHAR } from './const.js';
+import { getCol, getLine } from './get-location.js';
+import { ParserError } from './parser-error.js';
+export function ignoreBlock(source, tags, maskChar = MASK_CHAR) {
     let replaced = source;
     const stack = [];
     for (const tag of tags) {
-        // Replace tags in attributes
-        const attr = maskText(prepend(tag.start, '(?<=(?:"|\'))'), append(tag.end, '(?=(?:"|\'))'), replaced, (startTag, taggedCode, endTag) => {
-            const mask = maskChar.repeat(startTag.length) +
-                taggedCode.replace(/[^\n]/g, maskChar) +
-                maskChar.repeat((endTag !== null && endTag !== void 0 ? endTag : '').length);
-            return mask;
-        });
-        replaced = attr.replaced;
-        stack.push(...attr.stack.map(res => ({ ...res, type: tag.type })));
-        // Replace tags in other nodes
         const text = maskText(tag.start, tag.end, replaced, (startTag, taggedCode, endTag) => {
             const mask = maskChar.repeat(startTag.length) +
-                taggedCode.replace(/[^\n]/g, maskChar) +
-                maskChar.repeat((endTag !== null && endTag !== void 0 ? endTag : '').length);
+                taggedCode.replaceAll(/[^\n]/g, maskChar) +
+                maskChar.repeat((endTag ?? '').length);
             const taggedMask = `<!${mask.slice(2).slice(0, -1)}>`;
             return taggedMask;
         });
@@ -37,7 +23,6 @@ function ignoreBlock(source, tags, maskChar = const_1.MASK_CHAR) {
         maskChar,
     };
 }
-exports.ignoreBlock = ignoreBlock;
 function maskText(start, end, replaced, masking) {
     const stack = [];
     start = removeGlobalOption(start);
@@ -52,121 +37,56 @@ function maskText(start, end, replaced, masking) {
             index,
             startTag,
             taggedCode,
-            endTag: endTag !== null && endTag !== void 0 ? endTag : null,
+            endTag: endTag ?? null,
+            resolved: false,
         });
         /**
          * It will not replace line breaks because detects line number.
          */
-        replaced = above + masking(startTag, taggedCode, endTag) + (below !== null && below !== void 0 ? below : '');
+        replaced = above + masking(startTag, taggedCode, endTag) + (below ?? '');
     }
     return {
         replaced,
         stack,
     };
 }
-function restoreNode(
+export function restoreNode(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+parser, nodeList, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nodeList, ignoreBlock) {
-    var _a, _b, _c, _d, _e;
-    nodeList = nodeList.slice();
+ignoreBlock, throwErrorWhenTagHasUnresolved = true) {
+    const newNodeList = [...nodeList];
     const { source, stack, maskChar } = ignoreBlock;
-    for (const node of nodeList) {
-        if (node.type === 'comment' || node.type === 'text' || node.type === 'psblock') {
-            if (!hasIgnoreBlock(node.raw, maskChar)) {
-                continue;
-            }
-            const parentNode = node.parentNode;
-            const index = nodeList.findIndex(n => n === node);
-            const insertList = [];
-            let text = node.raw;
-            let pointer = 0;
-            for (const tag of stack) {
-                if (node.startOffset <= tag.index && tag.index < node.endOffset) {
-                    const start = tag.index - node.startOffset;
-                    const body = tag.startTag + tag.taggedCode + ((_a = tag.endTag) !== null && _a !== void 0 ? _a : '');
-                    const above = node.raw.slice(pointer, start);
-                    const below = text.slice(above.length + body.length);
-                    if (above) {
-                        const offset = node.startOffset + pointer;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + above.length);
-                        const textNode = {
-                            ...node,
-                            uuid: (0, create_token_1.uuid)(),
-                            type: 'text',
-                            raw,
-                            startOffset,
-                            endOffset,
-                            startLine,
-                            endLine,
-                            startCol,
-                            endCol,
-                        };
-                        if ((_b = node.prevNode) === null || _b === void 0 ? void 0 : _b.nextNode) {
-                            node.prevNode.nextNode = textNode;
-                        }
-                        if ((_c = node.nextNode) === null || _c === void 0 ? void 0 : _c.prevNode) {
-                            node.nextNode.prevNode = textNode;
-                        }
-                        insertList.push(textNode);
-                    }
-                    if (body) {
-                        const offset = node.startOffset + pointer + above.length;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + body.length);
-                        const bodyNode = {
-                            uuid: (0, create_token_1.uuid)(),
-                            type: 'psblock',
-                            nodeName: `#ps:${tag.type}`,
-                            raw,
-                            parentNode: node.parentNode,
-                            prevNode: null,
-                            nextNode: null,
-                            isFragment: node.isFragment,
-                            isGhost: false,
-                            startOffset,
-                            endOffset,
-                            startLine,
-                            endLine,
-                            startCol,
-                            endCol,
-                        };
-                        if ((_d = node.prevNode) === null || _d === void 0 ? void 0 : _d.nextNode) {
-                            node.prevNode.nextNode = bodyNode;
-                        }
-                        if ((_e = node.nextNode) === null || _e === void 0 ? void 0 : _e.prevNode) {
-                            node.nextNode.prevNode = bodyNode;
-                        }
-                        insertList.push(bodyNode);
-                    }
-                    text = below;
-                    pointer = start + body.length;
-                }
-            }
-            if (text) {
-                const offset = node.endOffset - text.length;
-                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + text.length);
-                const textNode = {
-                    ...node,
-                    uuid: (0, create_token_1.uuid)(),
-                    type: 'text',
-                    raw,
-                    startOffset,
-                    endOffset,
-                    startLine,
-                    endLine,
-                    startCol,
-                    endCol,
-                };
-                insertList.push(textNode);
-            }
-            (0, siblings_correction_1.siblingsCorrection)(insertList);
-            if (parentNode) {
-                parentNode.childNodes = insertList;
-            }
-            nodeList.splice(index, 1, ...insertList);
+    if (stack.length === 0) {
+        return newNodeList;
+    }
+    for (const tag of stack) {
+        const node = newNodeList.find(node => node.startOffset === tag.index);
+        if (!node) {
+            continue;
+        }
+        const raw = `${tag.startTag}${tag.taggedCode}${tag.endTag ?? ''}`;
+        const token = parser.createToken(raw, node.startOffset, node.startLine, node.startCol);
+        const psNode = {
+            ...token,
+            type: 'psblock',
+            depth: node.depth,
+            nodeName: `#ps:${tag.type}`,
+            parentNode: node.parentNode,
+            childNodes: [],
+            isBogus: false,
+        };
+        if (node.type !== 'doctype' && node.parentNode?.childNodes) {
+            parser.replaceChild(node.parentNode, node, psNode);
         }
+        const index = newNodeList.indexOf(node);
+        newNodeList.splice(index, 1, psNode);
+        tag.resolved = true;
+    }
+    for (const node of newNodeList) {
         if (node.type === 'starttag') {
             for (const attr of node.attributes) {
-                if (attr.type === 'ps-attr' || attr.value.raw === '' || !hasIgnoreBlock(attr.value.raw, maskChar)) {
+                if (attr.type === 'spread' || attr.value.raw === '' || !hasIgnoreBlock(attr.value.raw, maskChar)) {
                     continue;
                 }
                 for (const tag of stack) {
@@ -176,16 +96,40 @@ nodeList, ignoreBlock) {
                         const offset = tag.index - attr.value.startOffset;
                         const above = attr.value.raw.slice(0, offset);
                         const below = attr.value.raw.slice(offset + length);
-                        attr.value.raw = above + raw + below;
-                        attr.isDynamicValue = true;
+                        parser.updateRaw(attr.value, above + raw + below);
+                        parser.updateAttr(attr, { isDynamicValue: true });
+                        tag.resolved = true;
                     }
+                    parser.updateRaw(attr, attr.name.raw +
+                        attr.spacesBeforeEqual.raw +
+                        attr.equal.raw +
+                        attr.spacesAfterEqual.raw +
+                        attr.startQuote.raw +
+                        attr.value.raw +
+                        attr.endQuote.raw);
                 }
+                // Update node raw
+                const length = attr.raw.length;
+                const offset = attr.startOffset - node.startOffset;
+                const above = node.raw.slice(0, offset);
+                const below = node.raw.slice(offset + length);
+                parser.updateRaw(node, above + attr.raw + below);
+            }
+        }
+    }
+    if (throwErrorWhenTagHasUnresolved) {
+        for (const tag of stack) {
+            if (!tag.resolved) {
+                throw new ParserError('Parsing failed. Unsupported syntax detected', {
+                    line: getLine(source, tag.index),
+                    col: getCol(source, tag.index),
+                    raw: tag.startTag + tag.taggedCode + (tag.endTag ?? ''),
+                });
             }
         }
     }
-    return nodeList;
+    return newNodeList;
 }
-exports.restoreNode = restoreNode;
 function snap(str, reg) {
     const matched = reg.exec(str);
     if (!matched) {
@@ -198,14 +142,14 @@ function snap(str, reg) {
     return [index, above, snapPoint, below];
 }
 function removeGlobalOption(reg) {
+    if (typeof reg === 'string') {
+        return new RegExp(escapeRegExpForStr(reg));
+    }
     return new RegExp(reg.source, reg.ignoreCase ? 'i' : '');
 }
-function prepend(reg, str) {
-    return new RegExp(str + reg.source, reg.ignoreCase ? 'i' : '');
-}
-function append(reg, str) {
-    return new RegExp(reg.source + str, reg.ignoreCase ? 'i' : '');
-}
 function hasIgnoreBlock(textContent, maskChar) {
     return textContent.includes(maskChar);
 }
+function escapeRegExpForStr(str) {
+    return str.replaceAll(/[!$()*+./:=?[\\\]^{|}]/g, '\\$&');
+}

package/lib/ignore-front-matter.d.ts

@@ -1 +1,4 @@
-export declare function ignoreFrontMatter(code: string): string;
+export declare function ignoreFrontMatter(code: string): {
+    code: string;
+    frontMatter: string | null;
+};

package/lib/ignore-front-matter.js

@@ -1,21 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ignoreFrontMatter = void 0;
-function ignoreFrontMatter(code) {
-    const reStart = /^(?:\s*\r?\n)?---\r?\n/.exec(code);
+export function ignoreFrontMatter(code) {
+    const reStart = /^(?:\s*\n)?---\r?\n/.exec(code);
     if (!reStart) {
-        return code;
+        return {
+            code,
+            frontMatter: null,
+        };
     }
     const startPoint = reStart[0].length;
     const afterStart = code.slice(startPoint);
     const reEnd = /\r?\n---\r?\n/.exec(afterStart);
     if (!reEnd) {
-        return code;
+        return {
+            code,
+            frontMatter: null,
+        };
     }
     const endPoint = startPoint + reEnd.index + reEnd[0].length;
     const frontMatter = code.slice(0, endPoint);
     const afterCode = code.slice(endPoint);
-    const masked = frontMatter.replace(/[^\r\n]/g, ' ');
-    return masked + afterCode;
+    const masked = frontMatter.replaceAll(/[^\n\r]/g, ' ');
+    return {
+        code: masked + afterCode,
+        frontMatter,
+    };
 }
-exports.ignoreFrontMatter = ignoreFrontMatter;

package/lib/index.d.ts

@@ -1,16 +1,7 @@
-export * from './const';
-export * from './create-token';
-export * from './debugger';
-export * from './decision';
-export * from './detect-element-type';
-export * from './flatten-nodes';
-export * from './get-location';
-export * from './get-space-before';
-export * from './idl-attributes';
-export * from './ignore-block';
-export * from './ignore-front-matter';
-export * from './parse-attr';
-export * from './parser-error';
-export * from './remove-deprecated-node';
-export * from './tag-splitter';
-export * from './walker';
+export * from './debugger.js';
+export * from './enums.js';
+export * from './idl-attributes.js';
+export * from './parser-error.js';
+export * from './parser.js';
+export * from './script-parser.js';
+export * from './types.js';

package/lib/index.js

@@ -1,19 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./const"), exports);
-tslib_1.__exportStar(require("./create-token"), exports);
-tslib_1.__exportStar(require("./debugger"), exports);
-tslib_1.__exportStar(require("./decision"), exports);
-tslib_1.__exportStar(require("./detect-element-type"), exports);
-tslib_1.__exportStar(require("./flatten-nodes"), exports);
-tslib_1.__exportStar(require("./get-location"), exports);
-tslib_1.__exportStar(require("./get-space-before"), exports);
-tslib_1.__exportStar(require("./idl-attributes"), exports);
-tslib_1.__exportStar(require("./ignore-block"), exports);
-tslib_1.__exportStar(require("./ignore-front-matter"), exports);
-tslib_1.__exportStar(require("./parse-attr"), exports);
-tslib_1.__exportStar(require("./parser-error"), exports);
-tslib_1.__exportStar(require("./remove-deprecated-node"), exports);
-tslib_1.__exportStar(require("./tag-splitter"), exports);
-tslib_1.__exportStar(require("./walker"), exports);
+export * from './debugger.js';
+export * from './enums.js';
+export * from './idl-attributes.js';
+export * from './parser-error.js';
+export * from './parser.js';
+export * from './script-parser.js';
+export * from './types.js';

package/lib/parser-error.d.ts

@@ -1,32 +1,27 @@
 export type ParserErrorInfo = {
-	readonly line?: number;
-	readonly col?: number;
-	readonly raw?: string;
+    readonly line?: number;
+    readonly col?: number;
+    readonly raw?: string;
+    readonly stack?: string;
 };
 export declare class ParserError extends Error {
-	readonly col: number;
-	readonly line: number;
-	name: string;
-	readonly raw: string;
-	constructor(message: string, info: ParserErrorInfo);
+    readonly col: number;
+    readonly line: number;
+    name: string;
+    readonly raw: string;
+    constructor(message: string, info: ParserErrorInfo);
 }
 export declare class TargetParserError extends ParserError {
-	name: string;
-	readonly nodeName: string | null;
-	constructor(
-		message: string,
-		info: ParserErrorInfo & {
-			readonly nodeName?: string | null;
-		},
-	);
+    name: string;
+    readonly nodeName: string | null;
+    constructor(message: string, info: ParserErrorInfo & {
+        readonly nodeName?: string | null;
+    });
 }
 export declare class ConfigParserError extends ParserError {
-	readonly filePath: string;
-	name: string;
-	constructor(
-		message: string,
-		info: ParserErrorInfo & {
-			readonly filePath: string;
-		},
-	);
+    readonly filePath: string;
+    name: string;
+    constructor(message: string, info: ParserErrorInfo & {
+        readonly filePath: string;
+    });
 }

package/lib/parser-error.js

@@ -1,30 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigParserError = exports.TargetParserError = exports.ParserError = void 0;
-class ParserError extends Error {
+export class ParserError extends Error {
     constructor(message, info) {
-        var _a, _b, _c;
         super(message);
         this.name = 'ParserError';
-        this.line = (_a = info.line) !== null && _a !== void 0 ? _a : 1;
-        this.col = (_b = info.col) !== null && _b !== void 0 ? _b : 0;
-        this.raw = (_c = info.raw) !== null && _c !== void 0 ? _c : '';
+        this.line = info.line ?? 1;
+        this.col = info.col ?? 0;
+        this.raw = info.raw ?? '';
+        this.stack = info.stack ?? this.stack;
     }
 }
-exports.ParserError = ParserError;
-class TargetParserError extends ParserError {
+export class TargetParserError extends ParserError {
     constructor(message, info) {
-        var _a;
         const errMsg = info.nodeName
             ? `The ${info.nodeName} is invalid element (${info.line}:${info.col}): ${message}`
             : message;
         super(errMsg, info);
         this.name = 'TargetParserError';
-        this.nodeName = (_a = info.nodeName) !== null && _a !== void 0 ? _a : null;
+        this.nodeName = info.nodeName ?? null;
     }
 }
-exports.TargetParserError = TargetParserError;
-class ConfigParserError extends ParserError {
+export class ConfigParserError extends ParserError {
     constructor(message, info) {
         const pos = info.line != null && info.line != null ? `(${info.line}:${info.col})` : '';
         const file = ` in ${info.filePath}${pos}`;
@@ -34,4 +28,3 @@ class ConfigParserError extends ParserError {
         this.filePath = info.filePath;
     }
 }
-exports.ConfigParserError = ConfigParserError;

package/lib/parser.d.ts

@@ -0,0 +1,108 @@
+import type { Token, ChildToken, QuoteSet, ParseOptions, ParserOptions, Tokenized } from './types.js';
+import type { EndTagType, MLASTDocument, MLASTParentNode, MLParser, ParserAuthoredElementNameDistinguishing, MLASTElement, MLASTElementCloseTag, MLASTToken, MLASTNodeTreeItem, MLASTTag, MLASTText, MLASTAttr, MLASTChildNode, MLASTSpreadAttr, ElementType, Walker, MLASTHTMLAttr } from '@markuplint/ml-ast';
+import { AttrState } from './enums.js';
+import { ParserError } from './parser-error.js';
+export declare abstract class Parser<Node extends {} = {}, State extends unknown = null> implements MLParser {
+    #private;
+    state: State;
+    get authoredElementName(): ParserAuthoredElementNameDistinguishing | undefined;
+    /**
+     * Detect value as a true if its attribute is booleanish value and omitted.
+     *
+     * Ex:
+     * ```jsx
+     * <Component aria-hidden />
+     * ```
+     *
+     * In the above, the `aria-hidden` is `true`.
+     */
+    get booleanish(): boolean;
+    /**
+     * The end tag omittable type.
+     *
+     * - `"xml"`: Must need an end tag or must self-close
+     * - `"omittable"`: May omit
+     * - `"never"`: Never need
+     */
+    get endTag(): EndTagType;
+    get rawCode(): string;
+    get tagNameCaseSensitive(): boolean;
+    constructor(options?: ParserOptions, defaultState?: State);
+    tokenize(): Tokenized<Node, State>;
+    beforeParse(rawCode: string, options?: ParseOptions): string;
+    parse(rawCode: string, options?: ParseOptions): MLASTDocument;
+    afterParse(nodeList: readonly MLASTNodeTreeItem[], options?: ParseOptions): readonly MLASTNodeTreeItem[];
+    parseError(error: any): ParserError;
+    traverse(originNodes: readonly Node[], parentNode: MLASTParentNode | null | undefined, depth: number): {
+        childNodes: readonly MLASTChildNode[];
+        siblings: readonly MLASTNodeTreeItem[];
+    };
+    afterTraverse(nodeTree: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    nodeize(originNode: Node, parentNode: MLASTParentNode | null, depth: number): readonly MLASTNodeTreeItem[];
+    afterNodeize(siblings: readonly MLASTNodeTreeItem[], parentNode: MLASTParentNode | null, depth: number): {
+        siblings: MLASTChildNode[];
+        ancestors: MLASTNodeTreeItem[];
+    };
+    flattenNodes(nodeTree: readonly MLASTNodeTreeItem[]): readonly MLASTNodeTreeItem[];
+    afterFlattenNodes(nodeList: readonly MLASTNodeTreeItem[], options?: {
+        readonly exposeInvalidNode?: boolean;
+        readonly exposeWhiteSpace?: boolean;
+        readonly concatText?: boolean;
+    }): readonly MLASTNodeTreeItem[];
+    visitDoctype(token: ChildToken & {
+        readonly name: string;
+        readonly publicId: string;
+        readonly systemId: string;
+    }): readonly MLASTNodeTreeItem[];
+    visitComment(token: ChildToken, options?: {
+        readonly isBogus?: boolean;
+    }): readonly MLASTNodeTreeItem[];
+    visitText(token: ChildToken, options?: {
+        readonly researchTags?: boolean;
+        readonly invalidTagAsText?: boolean;
+    }): readonly MLASTNodeTreeItem[];
+    visitElement(token: ChildToken & {
+        readonly nodeName: string;
+        readonly namespace: string;
+    }, childNodes?: readonly Node[], options?: {
+        readonly createEndTagToken?: (startTag: MLASTElement) => ChildToken | null;
+        readonly namelessFragment?: boolean;
+        readonly overwriteProps?: Partial<MLASTElement>;
+    }): readonly MLASTNodeTreeItem[];
+    visitPsBlock(token: ChildToken & {
+        readonly nodeName: string;
+    }, childNodes?: readonly Node[], originBlockNode?: Node): readonly MLASTNodeTreeItem[];
+    visitChildren(children: readonly Node[], parentNode: MLASTParentNode | null): readonly MLASTNodeTreeItem[];
+    visitSpreadAttr(token: Token): MLASTSpreadAttr | null;
+    visitAttr(token: Token, options?: {
+        readonly quoteSet?: readonly QuoteSet[];
+        readonly quoteInValueChars?: readonly QuoteSet[];
+        readonly endOfUnquotedValueChars?: readonly string[];
+        readonly startState?: AttrState;
+    }): MLASTAttr & {
+        __rightText?: string;
+    };
+    parseCodeFragment(token: ChildToken, options?: {
+        readonly namelessFragment?: boolean;
+    }): (MLASTTag | MLASTText)[];
+    updateLocation(node: MLASTNodeTreeItem, props: Partial<Pick<MLASTNodeTreeItem, 'startOffset' | 'startLine' | 'startCol' | 'depth'>>): void;
+    /**
+     * Set new raw code to target node.
+     *
+     * Replace the raw code and update the start/end offset/line/column.
+     *
+     * @param node target node
+     * @param raw new raw code
+     */
+    updateRaw(node: MLASTToken, raw: string): void;
+    updateElement(el: MLASTElement, props: Partial<Pick<MLASTElement, 'nodeName' | 'elementType'>>): void;
+    updateElement(el: MLASTElementCloseTag, props: Partial<Pick<MLASTElementCloseTag, 'nodeName'>>): void;
+    updateAttr(attr: MLASTHTMLAttr, props: Partial<Pick<MLASTHTMLAttr, 'isDynamicValue' | 'isDirective' | 'potentialName' | 'potentialValue' | 'valueType' | 'candidate' | 'isDuplicatable'>>): void;
+    detectElementType(nodeName: string, defaultPattern?: ParserAuthoredElementNameDistinguishing): ElementType;
+    createToken(token: Token): MLASTToken;
+    createToken(token: string, startOffset: number, startLine: number, startCol: number): MLASTToken;
+    sliceFragment(start: number, end?: number): Token;
+    walk<Node extends MLASTNodeTreeItem>(nodeList: readonly Node[], walker: Walker<Node>, depth?: number): void;
+    appendChild(parentNode: MLASTParentNode | null, ...childNodes: readonly MLASTChildNode[]): void;
+    replaceChild(parentNode: MLASTParentNode, oldChildNode: MLASTChildNode, newChildNode: MLASTChildNode): void;
+}