@markuplint/parser-utils 3.0.0-canary.5 → 3.0.0-dev.177

package/lib/parse-attr.d.ts

@@ -0,0 +1,27 @@
+import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
+type ParseAttrOptions = {
+	readonly booleanish?: boolean;
+	readonly valueDelimiters?: readonly ValueDelimiter[];
+	readonly equal?: string;
+};
+type ValueDelimiter = {
+	readonly start: string;
+	readonly end: string;
+};
+export declare const defaultValueDelimiters: readonly ValueDelimiter[];
+export declare function parseAttr(raw: string, offset: number, html: string, options?: ParseAttrOptions): MLASTHTMLAttr;
+export declare function tokenize(
+	raw: string,
+	options?: ParseAttrOptions,
+): {
+	beforeName: string;
+	name: string;
+	afterName: string;
+	equal: string;
+	beforeValue: string;
+	startQuote: string;
+	value: string;
+	endQuote: string;
+	afterAttr: string;
+};
+export {};

package/lib/parse-attr.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = exports.parseAttr = exports.defaultValueDelimiters = void 0;
+const create_token_1 = require("./create-token");
+exports.defaultValueDelimiters = [
+    {
+        start: "'",
+        end: "'",
+    },
+    {
+        start: '"',
+        end: '"',
+    },
+];
+const defaultEqual = '=';
+const spaceRegex = /^\s$/;
+function parseAttr(raw, offset, html, options) {
+    const tokens = tokenize(raw, options);
+    tokens.beforeName;
+    const attrToken = (0, create_token_1.createTokenFromRawCode)(raw, offset, html);
+    const spacesBeforeName = (0, create_token_1.tokenizer)(tokens.beforeName, attrToken.startLine, attrToken.startCol, attrToken.startOffset);
+    const name = (0, create_token_1.tokenizer)(tokens.name, spacesBeforeName.endLine, spacesBeforeName.endCol, spacesBeforeName.endOffset);
+    const spacesBeforeEqual = (0, create_token_1.tokenizer)(tokens.afterName, name.endLine, name.endCol, name.endOffset);
+    const equal = (0, create_token_1.tokenizer)(tokens.equal, spacesBeforeEqual.endLine, spacesBeforeEqual.endCol, spacesBeforeEqual.endOffset);
+    const spacesAfterEqual = (0, create_token_1.tokenizer)(tokens.beforeValue, equal.endLine, equal.endCol, equal.endOffset);
+    const startQuote = (0, create_token_1.tokenizer)(tokens.startQuote, spacesAfterEqual.endLine, spacesAfterEqual.endCol, spacesAfterEqual.endOffset);
+    const value = (0, create_token_1.tokenizer)(tokens.value, startQuote.endLine, startQuote.endCol, startQuote.endOffset);
+    const endQuote = (0, create_token_1.tokenizer)(tokens.endQuote, value.endLine, value.endCol, value.endOffset);
+    const attr = {
+        type: 'html-attr',
+        uuid: (0, create_token_1.uuid)(),
+        raw: attrToken.raw,
+        startOffset: attrToken.startOffset,
+        endOffset: attrToken.endOffset,
+        startLine: attrToken.startLine,
+        endLine: attrToken.endLine,
+        startCol: attrToken.startCol,
+        endCol: attrToken.endCol,
+        spacesBeforeName,
+        name,
+        spacesBeforeEqual,
+        equal,
+        spacesAfterEqual,
+        startQuote,
+        value,
+        endQuote,
+        isDuplicatable: false,
+        nodeName: name.raw,
+        parentNode: null,
+        nextNode: null,
+        prevNode: null,
+        isFragment: false,
+        isGhost: false,
+    };
+    return attr;
+}
+exports.parseAttr = parseAttr;
+function tokenize(raw, options) {
+    var _a, _b, _c;
+    const valueDelimiters = (_a = options === null || options === void 0 ? void 0 : options.valueDelimiters) !== null && _a !== void 0 ? _a : exports.defaultValueDelimiters;
+    const equalDelimiter = (_b = options === null || options === void 0 ? void 0 : options.equal) !== null && _b !== void 0 ? _b : defaultEqual;
+    let state = 'b-name';
+    const charactors = raw.split('');
+    let beforeName = '';
+    let name = '';
+    let afterName = '';
+    let equal = '';
+    let valueDelimiter = null;
+    let beforeValue = '';
+    let startQuote = '';
+    let value = '';
+    let endQuote = '';
+    let afterAttr = '';
+    while (charactors.length > 0) {
+        const charactor = charactors.shift();
+        if (state === 'b-name') {
+            if (spaceRegex.test(charactor)) {
+                beforeName += charactor;
+                continue;
+            }
+            name += charactor;
+            state = 'name';
+            continue;
+        }
+        if (state === 'name') {
+            if (equalDelimiter === charactor) {
+                equal = equalDelimiter;
+                state = 'value-start';
+                continue;
+            }
+            if (spaceRegex.test(charactor)) {
+                afterName += charactor;
+                state = 'a-name';
+                continue;
+            }
+            name += charactor;
+            continue;
+        }
+        if (state === 'a-name') {
+            if (equalDelimiter === charactor) {
+                equal = equalDelimiter;
+                state = 'value-start';
+                continue;
+            }
+            if (spaceRegex.test(charactor)) {
+                afterName += charactor;
+                continue;
+            }
+            break;
+        }
+        if (state === 'value-start') {
+            if (spaceRegex.test(charactor)) {
+                beforeValue += charactor;
+                continue;
+            }
+            valueDelimiter = (_c = valueDelimiters.find(d => d.start === charactor)) !== null && _c !== void 0 ? _c : null;
+            if (valueDelimiter) {
+                startQuote += valueDelimiter.start;
+            }
+            else {
+                value += beforeValue + charactor;
+                beforeValue = '';
+            }
+            state = 'value';
+            continue;
+        }
+        if (state !== 'value') {
+            throw new Error('ParseError: unknown parse state in the attribute');
+        }
+        value += charactor;
+    }
+    if (valueDelimiter) {
+        const endQuoteIndex = value.lastIndexOf(valueDelimiter.end);
+        endQuote = value.slice(endQuoteIndex, endQuoteIndex + 1);
+        afterAttr = value.slice(endQuoteIndex + 1);
+        value = value.slice(0, endQuoteIndex);
+    }
+    return {
+        beforeName,
+        name,
+        afterName,
+        equal,
+        beforeValue,
+        startQuote,
+        value,
+        endQuote,
+        afterAttr,
+    };
+}
+exports.tokenize = tokenize;

package/lib/parser-error.d.ts

@@ -1,13 +1,21 @@
 export declare class ParserError extends Error {
-    readonly col: number;
-    readonly line: number;
-    name: string;
-    readonly nodeName: string | null;
-    readonly raw: string;
-    constructor(message: string, { line, col, raw, nodeName, }: {
-        line?: number;
-        col?: number;
-        raw?: string;
-        nodeName?: string | null;
-    });
+	readonly col: number;
+	readonly line: number;
+	name: string;
+	readonly nodeName: string | null;
+	readonly raw: string;
+	constructor(
+		message: string,
+		{
+			line,
+			col,
+			raw,
+			nodeName,
+		}: {
+			readonly line?: number;
+			readonly col?: number;
+			readonly raw?: string;
+			readonly nodeName?: string | null;
+		},
+	);
 }

package/lib/remove-deprecated-node.d.ts

@@ -0,0 +1,7 @@
+import type { MLASTNode } from '@markuplint/ml-ast';
+/**
+ *
+ * @disruptive
+ * @param nodeOrders [Disruptive change]
+ */
+export declare function removeDeprecatedNode(nodeOrders: MLASTNode[]): void;

package/lib/remove-deprecated-node.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDeprecatedNode = void 0;
+/**
+ *
+ * @disruptive
+ * @param nodeOrders [Disruptive change]
+ */
+function removeDeprecatedNode(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeOrders) {
+    /**
+     * sorting
+     */
+    nodeOrders.sort((a, b) => {
+        if (a.isGhost || b.isGhost) {
+            return 0;
+        }
+        return a.startOffset - b.startOffset;
+    });
+    /**
+     * remove duplicated node
+     */
+    const stack = {};
+    const removeIndexes = [];
+    nodeOrders.forEach((node, i) => {
+        if (node.isGhost) {
+            return;
+        }
+        const id = `${node.startLine}:${node.startCol}:${node.endLine}:${node.endCol}`;
+        if (stack[id] != null) {
+            removeIndexes.push(i);
+        }
+        stack[id] = i;
+    });
+    let r = nodeOrders.length;
+    while (r-- > 0) {
+        if (removeIndexes.includes(r)) {
+            nodeOrders.splice(r, 1);
+        }
+    }
+}
+exports.removeDeprecatedNode = removeDeprecatedNode;

package/lib/siblings-correction.js

@@ -8,11 +8,17 @@ exports.siblingsCorrection = void 0;
  * @affects nodeList[].prevNode
  * @affects nodeList[].nextNode
  */
-function siblingsCorrection(nodeList) {
+function siblingsCorrection(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList) {
+    var _a, _b;
     for (let i = 0; i < nodeList.length; i++) {
-        const prevNode = nodeList[i - 1] || null;
+        const prevNode = (_a = nodeList[i - 1]) !== null && _a !== void 0 ? _a : null;
         const node = nodeList[i];
-        const nextNode = nodeList[i + 1] || null;
+        if (!node) {
+            continue;
+        }
+        const nextNode = (_b = nodeList[i + 1]) !== null && _b !== void 0 ? _b : null;
         node.prevNode = prevNode;
         node.nextNode = nextNode;
     }

package/lib/tag-splitter.d.ts

@@ -0,0 +1,7 @@
+export interface N {
+	type: 'text' | 'starttag' | 'endtag' | 'comment' | 'boguscomment';
+	raw: string;
+	line: number;
+	col: number;
+}
+export default function tagSplitter(raw: string, line: number, col: number): N[];

package/lib/tag-splitter.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const const_1 = require("./const");
+const parser_utils_1 = require("@markuplint/parser-utils");
+function tagSplitter(raw, line, col) {
+    return withLocation(tagSplitterAsString(raw), line, col);
+}
+exports.default = tagSplitter;
+function tagSplitterAsString(raw) {
+    const tagMatches = raw.match(const_1.reSplitterTag);
+    if (!tagMatches) {
+        return [raw];
+    }
+    const tokens = Array.from(tagMatches);
+    tokens.unshift(); // remove all match
+    const nodes = [];
+    let rest = raw;
+    for (const token of tokens) {
+        const index = rest.indexOf(token);
+        let length = token.length;
+        if (index > 0) {
+            const text = rest.slice(0, index);
+            nodes.push(text);
+            length += text.length;
+        }
+        nodes.push(token);
+        rest = rest.slice(length);
+    }
+    if (rest) {
+        nodes.push(rest);
+    }
+    return nodes;
+}
+function withLocation(nodes, line, col) {
+    const result = [];
+    for (const node of nodes) {
+        if (node[0] !== '<') {
+            result.push({
+                type: 'text',
+                raw: node,
+                line,
+                col,
+            });
+        }
+        else {
+            const label = node.slice(1).slice(0, -1);
+            if (const_1.reTagName.test(label)) {
+                result.push({
+                    type: 'starttag',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '/') {
+                result.push({
+                    type: 'endtag',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '!') {
+                result.push({
+                    type: 'comment',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else if (label[0] === '?') {
+                result.push({
+                    type: 'boguscomment',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+            else {
+                result.push({
+                    type: 'text',
+                    raw: node,
+                    line,
+                    col,
+                });
+            }
+        }
+        line = (0, parser_utils_1.getEndLine)(node, line);
+        col = (0, parser_utils_1.getEndCol)(node, col);
+    }
+    return result;
+}

package/lib/types.d.ts

@@ -1,18 +1,18 @@
 export type Code = {
-    type: string;
-    index: number;
-    startTag: string;
-    taggedCode: string;
-    endTag: string | null;
+	readonly type: string;
+	readonly index: number;
+	readonly startTag: string;
+	readonly taggedCode: string;
+	readonly endTag: string | null;
 };
 export type IgnoreTag = {
-    type: string;
-    start: RegExp;
-    end: RegExp;
+	readonly type: string;
+	readonly start: Readonly<RegExp>;
+	readonly end: Readonly<RegExp>;
 };
 export type IgnoreBlock = {
-    source: string;
-    replaced: string;
-    stack: Code[];
-    maskChar: string;
+	readonly source: string;
+	readonly replaced: string;
+	readonly stack: readonly Code[];
+	readonly maskChar: string;
 };

package/lib/walker.d.ts

@@ -1,2 +1,2 @@
 import type { MLASTNode, Walker } from '@markuplint/ml-ast';
-export declare function walk(nodeList: MLASTNode[], walker: Walker, depth?: number): void;
+export declare function walk(nodeList: readonly MLASTNode[], walker: Walker, depth?: number): void;

package/lib/walker.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.walk = void 0;
-function walk(nodeList, walker, depth = 0) {
+function walk(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+nodeList, walker, depth = 0) {
     for (const node of nodeList) {
         walker(node, depth);
         if ('childNodes' in node) {
             if (node.type === 'endtag') {
                 continue;
             }
-            if (node.childNodes && node.childNodes.length) {
+            if (node.childNodes && node.childNodes.length > 0) {
                 walk(node.childNodes, walker, depth + 1);
             }
             if ('pearNode' in node && node.pearNode) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "3.0.0-canary.5+382d1365",
+	"version": "3.0.0-dev.177+e94f3601",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -11,18 +11,23 @@
 	"publishConfig": {
 		"access": "public"
 	},
+	"typedoc": {
+		"entryPoint": "./src/index.ts"
+	},
 	"scripts": {
 		"build": "tsc",
 		"clean": "tsc --build --clean"
 	},
-	"devDependencies": {
-		"@types/uuid": "^8.3.4"
-	},
 	"dependencies": {
-		"@markuplint/ml-ast": "3.0.0-canary.69+382d1365",
-		"@markuplint/types": "3.0.0-canary.5+382d1365",
-		"tslib": "^2.4.0",
-		"uuid": "8"
+		"@markuplint/ml-ast": "3.0.0-dev.177+e94f3601",
+		"@markuplint/types": "3.0.0-dev.177+e94f3601",
+		"@types/uuid": "^9.0.0",
+		"tslib": "^2.4.1",
+		"type-fest": "^3.8.0",
+		"uuid": "^9.0.0"
+	},
+	"peerDependencies": {
+		"@markuplint/ml-core": "3.x"
 	},
-	"gitHead": "382d13653071bd02210d5430403d1a87c840398c"
+	"gitHead": "e94f3601bf93366d1a2c7385ff7235817d82f7c9"
 }

package/test/create-token.spec.js

@@ -0,0 +1,17 @@
+const { tokenizer } = require('../lib/create-token');
+
+describe('tokenizer', () => {
+	it('empty', () => {
+		expect(tokenizer('', 1, 1, 0)).toEqual(
+			expect.objectContaining({
+				raw: '',
+				startLine: 1,
+				startCol: 1,
+				startOffset: 0,
+				endLine: 1,
+				endCol: 1,
+				endOffset: 0,
+			}),
+		);
+	});
+});

package/test/flatten-nodes.spec.js

@@ -0,0 +1,31 @@
+const { isDocumentFragment, createTree } = require('@markuplint/html-parser');
+
+const { flattenNodes } = require('../lib/flatten-nodes');
+
+function toTree(rawCode) {
+	const isFragment = isDocumentFragment(rawCode);
+	return createTree(rawCode, isFragment, 0, 0, 0);
+}
+
+describe('flattenNodes', () => {
+	it('a node', () => {
+		const raw = '<div></div>';
+		const tree = toTree(raw);
+		const list = flattenNodes(tree, raw);
+		expect(list.length).toStrictEqual(2);
+	});
+
+	it('one depth', () => {
+		const raw = '<div><span></span></div>';
+		const tree = toTree(raw);
+		const list = flattenNodes(tree, raw);
+		expect(list.length).toStrictEqual(4);
+	});
+
+	it('two depth', () => {
+		const raw = '<div><span><span></span></span></div>';
+		const tree = toTree(raw);
+		const list = flattenNodes(tree, raw);
+		expect(list.length).toStrictEqual(6);
+	});
+});

package/test/get-location.spec.js

@@ -0,0 +1,38 @@
+const { getEndCol, getEndLine } = require('../lib/get-location');
+
+describe('getEndLine', () => {
+	it('empty', () => {
+		expect(getEndLine('', 1)).toBe(1);
+		expect(getEndLine('', 3)).toBe(3);
+	});
+
+	it('basic', () => {
+		expect(getEndLine('\n\n', 2)).toBe(4);
+		expect(getEndLine('\n\n', 4)).toBe(6);
+		expect(getEndLine('\n\n  \n  \n  foo', 1)).toBe(5);
+		expect(getEndLine('\n\n  \n  \n  foo', 6)).toBe(10);
+	});
+});
+
+describe('getEndCol', () => {
+	it('empty', () => {
+		expect(getEndCol('', 1)).toBe(1);
+		expect(getEndCol('', 3)).toBe(3);
+	});
+
+	it('basic', () => {
+		expect(getEndCol('  ', 2)).toBe(4);
+		expect(getEndCol('  ', 4)).toBe(6);
+		expect(getEndCol('foo bar', 1)).toBe(8);
+		expect(getEndCol('foo bar', 6)).toBe(13);
+	});
+
+	it('with line break', () => {
+		expect(getEndCol('foo bar\n', 4)).toBe(1);
+		expect(getEndCol('foo bar\n', 4)).toBe(1);
+		expect(getEndCol('foo bar\n  ', 4)).toBe(3);
+		expect(getEndCol('foo bar\n  ', 4)).toBe(3);
+		expect(getEndCol('foo bar\nfoo bar', 1)).toBe(8);
+		expect(getEndCol('foo bar\nfoo bar', 6)).toBe(8);
+	});
+});