@markuplint/parser-utils 3.6.1 → 3.7.0

package/lib/get-space-before.d.ts

@@ -1 +1 @@
-export declare function getSpaceBefore(offset: number, rawCode: string): import("@markuplint/ml-ast").MLToken;
+export declare function getSpaceBefore(offset: number, rawCode: string): import('@markuplint/ml-ast').MLToken;

package/lib/parse-attr.d.ts

@@ -1,24 +1,27 @@
 import type { MLASTHTMLAttr } from '@markuplint/ml-ast';
 type ParseAttrOptions = {
-    readonly booleanish?: boolean;
-    readonly valueDelimiters?: readonly ValueDelimiter[];
-    readonly equal?: string;
+	readonly booleanish?: boolean;
+	readonly valueDelimiters?: readonly ValueDelimiter[];
+	readonly equal?: string;
 };
 type ValueDelimiter = {
-    readonly start: string;
-    readonly end: string;
+	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 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/parser-utils",
-	"version": "3.6.1",
+	"version": "3.7.0",
 	"description": "Utility module for markuplint parser plugin",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -18,18 +18,16 @@
 		"build": "tsc",
 		"clean": "tsc --build --clean"
 	},
-	"devDependencies": {
-		"@types/uuid": "^9.0.0",
-		"type-fest": "^3.7.0"
-	},
 	"dependencies": {
 		"@markuplint/ml-ast": "3.1.0",
-		"@markuplint/types": "3.5.1",
+		"@markuplint/types": "3.6.0",
+		"@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": "3cdf5a088b2da03773d5d4461d0e65ec32290a00"
+	"gitHead": "adc6e432cccba7cfad0dc8bf9f92e5aaf1107359"
 }

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);
+	});
+});

package/test/ignore-block.spec.js

@@ -0,0 +1,274 @@
+const { parse } = require('@markuplint/html-parser');
+
+const { nodeListToDebugMaps } = require('../lib/debugger');
+const { ignoreBlock, restoreNode } = require('../lib/ignore-block');
+
+const tags = [
+	{
+		type: 'ejs-tag',
+		start: /<%/,
+		end: /%>/,
+	},
+];
+
+describe('ignoreBlock', () => {
+	it('basic', () => {
+		const result = ignoreBlock('<div><%= test %></div>', tags);
+		expect(result).toStrictEqual({
+			source: '<div><%= test %></div>',
+			replaced: '<div><!></div>',
+			stack: [
+				{
+					type: 'ejs-tag',
+					index: 5,
+					startTag: '<%',
+					taggedCode: '= test ',
+					endTag: '%>',
+				},
+			],
+			maskChar: '',
+		});
+	});
+
+	it('2 tags', () => {
+		const result = ignoreBlock('<div><%= test %></div><div><%= test2 %></div>', tags);
+		expect(result).toStrictEqual({
+			source: '<div><%= test %></div><div><%= test2 %></div>',
+			replaced: '<div><!></div><div><!></div>',
+			stack: [
+				{
+					type: 'ejs-tag',
+					index: 5,
+					startTag: '<%',
+					taggedCode: '= test ',
+					endTag: '%>',
+				},
+				{
+					type: 'ejs-tag',
+					index: 27,
+					startTag: '<%',
+					taggedCode: '= test2 ',
+					endTag: '%>',
+				},
+			],
+			maskChar: '',
+		});
+	});
+
+	it('without closing tag', () => {
+		const result = ignoreBlock('<div><%= test', tags);
+		expect(result).toStrictEqual({
+			source: '<div><%= test',
+			replaced: '<div><!>',
+			stack: [
+				{
+					type: 'ejs-tag',
+					index: 5,
+					startTag: '<%',
+					taggedCode: '= test',
+					endTag: null,
+				},
+			],
+			maskChar: '',
+		});
+	});
+
+	it('with line break', () => {
+		const result = ignoreBlock('<div><% if () {\n\t\n} %></div>', tags);
+		expect(result).toStrictEqual({
+			source: '<div><% if () {\n\t\n} %></div>',
+			replaced: '<div><!\n\n></div>',
+			stack: [
+				{
+					type: 'ejs-tag',
+					index: 5,
+					startTag: '<%',
+					taggedCode: ' if () {\n\t\n} ',
+					endTag: '%>',
+				},
+			],
+			maskChar: '',
+		});
+	});
+
+	it('multiple tags', () => {
+		const result = ignoreBlock('<% 1 %>2<%= 3 %>4<%_ 5 _%>6<%- 7 -%>8<%% 9 %>', [
+			{
+				type: 'ejs-whitespace-slurping',
+				start: /<%_/,
+				end: /%>/,
+			},
+			{
+				type: 'ejs-output-value',
+				start: /<%=/,
+				end: /%>/,
+			},
+			{
+				type: 'ejs-output-unescaped',
+				start: /<%-/,
+				end: /%>/,
+			},
+			{
+				type: 'ejs-comment',
+				start: /<%#/,
+				end: /%>/,
+			},
+			{
+				type: 'ejs-scriptlet',
+				start: /<%(?!%)/,
+				end: /%>/,
+			},
+		]);
+
+		expect(result).toStrictEqual({
+			source: '<% 1 %>2<%= 3 %>4<%_ 5 _%>6<%- 7 -%>8<%% 9 %>',
+			replaced: '<!>2<!>4<!>6<!>8<%% 9 %>',
+			stack: [
+				{
+					type: 'ejs-scriptlet',
+					index: 0,
+					startTag: '<%',
+					taggedCode: ' 1 ',
+					endTag: '%>',
+				},
+				{
+					type: 'ejs-output-value',
+					index: 8,
+					startTag: '<%=',
+					taggedCode: ' 3 ',
+					endTag: '%>',
+				},
+				{
+					type: 'ejs-whitespace-slurping',
+					index: 17,
+					startTag: '<%_',
+					taggedCode: ' 5 _',
+					endTag: '%>',
+				},
+				{
+					type: 'ejs-output-unescaped',
+					index: 27,
+					startTag: '<%-',
+					taggedCode: ' 7 -',
+					endTag: '%>',
+				},
+			],
+			maskChar: '',
+		});
+	});
+});
+
+describe('restoreNode', () => {
+	it('basic', () => {
+		const code = '<div attr="<% attr %>"><% content %></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		const nodeMap = nodeListToDebugMaps(restoredAst, true);
+		// TODO: Remove the masks from Element.raw and Attribute.raw
+		expect(nodeMap).toStrictEqual([
+			'[1:1]>[1:24](0,23)div: <div␣attr="">',
+			'[1:6]>[1:23](5,22)attr: attr=""',
+			'  [1:5]>[1:6](4,5)bN: ␣',
+			'  [1:6]>[1:10](5,9)name: attr',
+			'  [1:10]>[1:10](9,9)bE: ',
+			'  [1:10]>[1:11](9,10)equal: =',
+			'  [1:11]>[1:11](10,10)aE: ',
+			'  [1:11]>[1:12](10,11)sQ: "',
+			'  [1:12]>[1:22](11,21)value: <%␣attr␣%>',
+			'  [1:22]>[1:23](21,22)eQ: "',
+			'  isDirective: false',
+			'  isDynamicValue: true',
+			'[1:24]>[1:37](23,36)#ps:ejs-tag: <%␣content␣%>',
+			'[1:37]>[1:43](36,42)div: </div>',
+		]);
+	});
+
+	it('tag', () => {
+		const code = '<title><% content %></title>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		const nodeMap = nodeListToDebugMaps(restoredAst);
+		expect(nodeMap).toStrictEqual([
+			'[1:1]>[1:8](0,7)title: <title>',
+			'[1:8]>[1:21](7,20)#ps:ejs-tag: <%␣content␣%>',
+			'[1:21]>[1:29](20,28)title: </title>',
+		]);
+	});
+
+	it('attr', () => {
+		const code = '<div attr="<% attr %><% attr2 %>"></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[0].attributes[0].value.raw).toBe('<% attr %><% attr2 %>');
+	});
+
+	it('attr', () => {
+		const code = '<div attr="<% attr %> <% attr2 %>"></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[0].attributes[0].value.raw).toBe('<% attr %> <% attr2 %>');
+	});
+
+	it('attr', () => {
+		const code = '<div attr="<% attr %>A<% attr2 %>"></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[0].attributes[0].value.raw).toBe('<% attr %>A<% attr2 %>');
+	});
+
+	it('before space', () => {
+		const code = '<div attr=" <% attr %>"></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[0].attributes[0].value.raw).toBe(' <% attr %>');
+	});
+
+	it('after space', () => {
+		const code = '<div attr=" <% attr %> "></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[0].attributes[0].value.raw).toBe(' <% attr %> ');
+	});
+
+	it('before char', () => {
+		const code = '<div attr="A<% attr %>"></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[0].attributes[0].value.raw).toBe('A<% attr %>');
+	});
+
+	it('after char', () => {
+		const code = '<div attr="A<% attr %>B"></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[0].attributes[0].value.raw).toBe('A<% attr %>B');
+	});
+
+	it('unexpected parsing', () => {
+		const code = '<div attr="<% attr %> "></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst).toStrictEqual([]);
+	});
+});
+
+describe('Issues', () => {
+	test('#607', () => {
+		const code = '<div><% %><img/></div>';
+		const masked = ignoreBlock(code, tags);
+		const ast = parse(masked.replaced);
+		const restoredAst = restoreNode(ast.nodeList, masked);
+		expect(restoredAst[2].parentNode?.uuid).toBe(restoredAst[0].uuid);
+		expect(restoredAst[2].prevNode?.uuid).toBe(restoredAst[1].uuid);
+	});
+});

package/test/ignore-front-matter.spec.js

@@ -0,0 +1,20 @@
+const { ignoreFrontMatter } = require('../lib/ignore-front-matter');
+
+describe('ignoreFrontMatter', () => {
+	it('basic', () => {
+		expect(ignoreFrontMatter('---')).toStrictEqual('---');
+		expect(ignoreFrontMatter('---\np: v')).toStrictEqual('---\np: v');
+		expect(ignoreFrontMatter('---\np: v\n---')).toStrictEqual('---\np: v\n---');
+		expect(ignoreFrontMatter('---\np: v\n---\n')).toStrictEqual('   \n    \n   \n');
+	});
+
+	it('basic', () => {
+		expect(
+			ignoreFrontMatter(`
+---
+prop: value
+---
+<html></html>`),
+		).toStrictEqual('\n   \n           \n   \n<html></html>');
+	});
+});

package/test/parse-attr.spec.js

@@ -0,0 +1,68 @@
+const { tokenize, defaultValueDelimiters } = require('../lib/parse-attr');
+
+describe('tokenize', () => {
+	test('name', () => {
+		expect(tokenize('a').name).toBe('a');
+		expect(tokenize('abc').name).toBe('abc');
+		expect(tokenize('abc:').name).toBe('abc:');
+		expect(tokenize(':abc').name).toBe(':abc');
+		expect(tokenize('xxx:abc').name).toBe('xxx:abc');
+		expect(tokenize('@abc').name).toBe('@abc');
+	});
+
+	test('value', () => {
+		expect(tokenize('a=b').value).toBe('b');
+		expect(tokenize('abc=xyz').value).toBe('xyz');
+		expect(tokenize('abc:="xyz"').value).toBe('xyz');
+	});
+
+	test('complex', () => {
+		expect(tokenize(' @a:x.y\n= x + y ')).toStrictEqual({
+			beforeName: ' ',
+			name: '@a:x.y',
+			afterName: '\n',
+			equal: '=',
+			beforeValue: '',
+			startQuote: '',
+			value: ' x + y ',
+			endQuote: '',
+			afterAttr: '',
+		});
+
+		expect(tokenize(' @a:x.y\n= " x\' + y " ')).toStrictEqual({
+			beforeName: ' ',
+			name: '@a:x.y',
+			afterName: '\n',
+			equal: '=',
+			beforeValue: ' ',
+			startQuote: '"',
+			value: " x' + y ",
+			endQuote: '"',
+			afterAttr: ' ',
+		});
+	});
+
+	test('jsx', () => {
+		expect(
+			tokenize(' className={classList.map((c) => `${c.toLowerCase()}`).join(",")} ', {
+				valueDelimiters: [
+					...defaultValueDelimiters,
+					{
+						start: '{',
+						end: '}',
+					},
+				],
+			}),
+		).toStrictEqual({
+			beforeName: ' ',
+			name: 'className',
+			afterName: '',
+			equal: '=',
+			beforeValue: '',
+			startQuote: '{',
+			value: 'classList.map((c) => `${c.toLowerCase()}`).join(",")',
+			endQuote: '}',
+			afterAttr: ' ',
+		});
+	});
+});