@monimesl/dot-dml-parser 0.1.0-alpha.10

package/README.md

@@ -0,0 +1 @@
+# @monimesl/dot-dml-parser

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { SourceError, SourceLocation } from "@monimesl/dot-core";
+//#region src/ast.d.ts
+interface DmlElementNode {
+  readonly type: 'Element';
+  readonly tag: string;
+  readonly events: Record<string, string>;
+  readonly attributes: Record<string, string>;
+  readonly children: DmlNode[];
+  readonly loc?: SourceLocation;
+}
+interface DmlTextNode {
+  readonly type: 'Text';
+  readonly content: string;
+  readonly loc?: SourceLocation;
+}
+type DmlNode = DmlElementNode | DmlTextNode;
+export declare function isElementNode(node: DmlNode): node is DmlElementNode;
+//#endregion
+//#region src/parse.d.ts
+interface ParseDmlOptions {
+  file?: string;
+  locations?: boolean;
+  whitespace?: 'trim' | 'collapse' | 'preserve';
+}
+/** Parses .dml markup into an IR tree, leaving `{{ }}` bindings as raw strings. */
+declare function parseDmlToIR(dmlString: string, options?: ParseDmlOptions): DmlNode[];
+//#endregion
+//#region src/errors.d.ts
+export declare class DmlParseError extends SourceError {
+  readonly name = "DmlParseError";
+}
+//#endregion
+export { type DmlElementNode, type DmlNode, type DmlTextNode, type ParseDmlOptions, parseDmlToIR };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/ast.ts","../src/parse.ts","../src/errors.ts"],"mappings":";;UAEiB;WACN;WACA;WACA,QAAQ;WACR,YAAY;WACZ,UAAU;WACV,MAAM;;UAGA;WACN;WACA;WACA,MAAM;;KAGL,UAAU,iBAAiB;wBAEvB,cAAc,MAAM,UAAU,QAAQ;;;UCbrC;EACf;EACA;EACA;;;iBAYO,aAAa,mBAAmB,UAAS,kBAAuB;;;qBCnB5D,sBAAsB;WACf"}

package/dist/index.js

@@ -0,0 +1,134 @@
+import { Parser } from "htmlparser2";
+import { SourceError, createLocator, isEventProp } from "@monimesl/dot-core";
+//#region src/errors.ts
+var DmlParseError = class extends SourceError {
+	name = "DmlParseError";
+};
+//#endregion
+//#region src/parse.ts
+const CLOSE_TAG = /<\/([^\s>]+)\s*>/g;
+const OPAQUE_REGION = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?]]>/g;
+/** Parses .dml markup into an IR tree, leaving `{{ }}` bindings as raw strings. */
+function parseDmlToIR(dmlString, options = {}) {
+	const { file, locations = false, whitespace = "trim" } = options;
+	const roots = [];
+	const stack = [];
+	let textBuffer = "";
+	let textStart = -1;
+	const closedAt = /* @__PURE__ */ new Set();
+	const locate = createLocator(dmlString);
+	const errorAt = (message, offset) => {
+		return new DmlParseError(message, file, locate(offset));
+	};
+	const currentChildren = () => {
+		return stack.at(-1)?.node.children ?? roots;
+	};
+	const flushText = () => {
+		if (textStart < 0) return;
+		const content = normalizeText(textBuffer, whitespace);
+		if (content.length > 0) {
+			let node;
+			if (locations) {
+				const leading = whitespace === "preserve" ? 0 : textBuffer.length - textBuffer.trimStart().length;
+				node = {
+					type: "Text",
+					content,
+					loc: locate(textStart + leading)
+				};
+			} else node = {
+				type: "Text",
+				content
+			};
+			currentChildren().push(node);
+		}
+		textBuffer = "";
+		textStart = -1;
+	};
+	let unfinishedTag;
+	const parser = new Parser({
+		onopentagname(name) {
+			unfinishedTag = {
+				name,
+				start: parser.startIndex
+			};
+		},
+		onopentag(name, attribs) {
+			unfinishedTag = void 0;
+			flushText();
+			const events = {};
+			const attributes = {};
+			for (const [attributeName, value] of Object.entries(attribs)) if (isEventProp(attributeName)) events[attributeName] = value;
+			else attributes[attributeName] = value;
+			const node = locations ? {
+				type: "Element",
+				tag: name,
+				attributes,
+				events,
+				children: [],
+				loc: locate(parser.startIndex)
+			} : {
+				type: "Element",
+				tag: name,
+				attributes,
+				events,
+				children: []
+			};
+			currentChildren().push(node);
+			stack.push({
+				node,
+				start: parser.startIndex
+			});
+		},
+		onclosetag(name, isImplied) {
+			flushText();
+			if (unfinishedTag) throw errorAt(`<${unfinishedTag.name}> isn't finished: add \`>\` or \`/>\``, unfinishedTag.start);
+			const tag = stack.pop();
+			const selfClosing = parser.startIndex === tag.start;
+			if (isImplied && !selfClosing) {
+				const found = parser.startIndex >= dmlString.length ? "end of input" : `\`${dmlString.slice(parser.startIndex, parser.endIndex + 1)}\``;
+				throw errorAt(`<${tag.node.tag}> isn't closed: expected </${tag.node.tag}>, found ${found}`, tag.start);
+			}
+			if (name !== tag.node.tag) throw errorAt(`</${name}> doesn't match <${tag.node.tag}>: expected </${tag.node.tag}>`, parser.startIndex);
+			if (!selfClosing) closedAt.add(parser.startIndex);
+		},
+		ontext(data) {
+			if (textStart < 0) textStart = parser.startIndex;
+			textBuffer += data;
+		},
+		oncomment() {
+			flushText();
+		},
+		onprocessinginstruction() {
+			flushText();
+		},
+		onerror(error) {
+			throw errorAt(error.message, parser.startIndex);
+		}
+	}, {
+		xmlMode: true,
+		decodeEntities: true,
+		recognizeCDATA: true
+	});
+	parser.write(dmlString);
+	parser.end();
+	flushText();
+	const stripped = dmlString.replace(OPAQUE_REGION, (region) => " ".repeat(region.length));
+	for (const closeTag of stripped.matchAll(CLOSE_TAG)) if (!closedAt.has(closeTag.index)) throw errorAt(`</${closeTag[1]}> has no matching opening tag`, closeTag.index);
+	return roots;
+}
+function normalizeText(raw, mode) {
+	switch (mode) {
+		case "preserve": return raw.trim().length === 0 ? "" : raw;
+		case "collapse": return raw.replace(/\s+/g, " ").trim();
+		case "trim": return raw.trim();
+	}
+}
+//#endregion
+//#region src/ast.ts
+function isElementNode(node) {
+	return node.type === "Element";
+}
+//#endregion
+export { DmlParseError, isElementNode, parseDmlToIR };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/errors.ts","../src/parse.ts","../src/ast.ts"],"sourcesContent":["import { SourceError } from '@monimesl/dot-core';\n\nexport class DmlParseError extends SourceError {\n  override readonly name = 'DmlParseError';\n}\n","import { Parser } from 'htmlparser2';\nimport { createLocator, isEventProp } from '@monimesl/dot-core';\n\nimport { DmlParseError } from './errors';\nimport type { DmlElementNode, DmlNode } from './ast';\n\nexport interface ParseDmlOptions {\n  file?: string;\n  locations?: boolean;\n  whitespace?: 'trim' | 'collapse' | 'preserve';\n}\n\nconst CLOSE_TAG = /<\\/([^\\s>]+)\\s*>/g;\nconst OPAQUE_REGION = /<!--[\\s\\S]*?-->|<!\\[CDATA\\[[\\s\\S]*?]]>/g;\n\ninterface OpenTag {\n  node: DmlElementNode;\n  start: number;\n}\n\n/** Parses .dml markup into an IR tree, leaving `{{ }}` bindings as raw strings. */\nfunction parseDmlToIR(dmlString: string, options: ParseDmlOptions = {}): DmlNode[] {\n  const { file, locations = false, whitespace = 'trim' } = options;\n  const roots: DmlNode[] = [];\n  const stack: OpenTag[] = [];\n  let textBuffer = '';\n  let textStart = -1;\n  const closedAt = new Set<number>();\n  const locate = createLocator(dmlString);\n  const errorAt = (message: string, offset: number) => {\n    return new DmlParseError(message, file, locate(offset));\n  };\n  const currentChildren = (): DmlNode[] => {\n    return stack.at(-1)?.node.children ?? roots;\n  };\n  const flushText = (): void => {\n    if (textStart < 0) {\n      return;\n    }\n    const content = normalizeText(textBuffer, whitespace);\n    if (content.length > 0) {\n      let node: DmlNode;\n      if (locations) {\n        const leading =\n          whitespace === 'preserve' ? 0 : textBuffer.length - textBuffer.trimStart().length;\n        node = { type: 'Text', content, loc: locate(textStart + leading) };\n      } else {\n        node = { type: 'Text', content };\n      }\n      currentChildren().push(node);\n    }\n    textBuffer = '';\n    textStart = -1;\n  };\n  // A tag whose name has been read but not its closing `>`.\n  let unfinishedTag: { name: string; start: number } | undefined;\n  const parser = new Parser(\n    {\n      onopentagname(name) {\n        unfinishedTag = { name, start: parser.startIndex };\n      },\n      onopentag(name, attribs) {\n        unfinishedTag = undefined;\n        flushText();\n        const events: Record<string, string> = {};\n        const attributes: Record<string, string> = {};\n        for (const [attributeName, value] of Object.entries(attribs)) {\n          if (isEventProp(attributeName)) {\n            events[attributeName] = value;\n          } else {\n            attributes[attributeName] = value;\n          }\n        }\n        const node: DmlElementNode = locations\n          ? {\n              type: 'Element',\n              tag: name,\n              attributes,\n              events,\n              children: [],\n              loc: locate(parser.startIndex),\n            }\n          : { type: 'Element', tag: name, attributes, events, children: [] };\n        currentChildren().push(node);\n        stack.push({ node, start: parser.startIndex });\n      },\n      onclosetag(name, isImplied) {\n        flushText();\n        if (unfinishedTag) {\n          throw errorAt(\n            `<${unfinishedTag.name}> isn't finished: add \\`>\\` or \\`/>\\``,\n            unfinishedTag.start,\n          );\n        }\n        // htmlparser2 only reports closing tags it has seen open.\n        const tag = stack.pop()!;\n        const selfClosing = parser.startIndex === tag.start;\n        if (isImplied && !selfClosing) {\n          const found =\n            parser.startIndex >= dmlString.length\n              ? 'end of input'\n              : `\\`${dmlString.slice(parser.startIndex, parser.endIndex + 1)}\\``;\n          throw errorAt(\n            `<${tag.node.tag}> isn't closed: expected </${tag.node.tag}>, found ${found}`,\n            tag.start,\n          );\n        }\n        if (name !== tag.node.tag) {\n          throw errorAt(\n            `</${name}> doesn't match <${tag.node.tag}>: expected </${tag.node.tag}>`,\n            parser.startIndex,\n          );\n        }\n        if (!selfClosing) {\n          closedAt.add(parser.startIndex);\n        }\n      },\n      ontext(data) {\n        // htmlparser2 splits text around entities; buffer until the next tag.\n        if (textStart < 0) {\n          textStart = parser.startIndex;\n        }\n        textBuffer += data;\n      },\n      oncomment() {\n        flushText();\n      },\n      onprocessinginstruction() {\n        flushText();\n      },\n      onerror(error) {\n        throw errorAt(error.message, parser.startIndex);\n      },\n    },\n    {\n      xmlMode: true,\n      decodeEntities: true,\n      recognizeCDATA: true,\n    },\n  );\n\n  parser.write(dmlString);\n  parser.end();\n  flushText();\n\n  // htmlparser2 ignores unmatched closing tags instead of throwing, so we catch them here.\n  // Comments and CDATA are blanked with spaces, not removed, so offsets still match the source.\n  const stripped = dmlString.replace(OPAQUE_REGION, (region) => ' '.repeat(region.length));\n  for (const closeTag of stripped.matchAll(CLOSE_TAG)) {\n    if (!closedAt.has(closeTag.index)) {\n      throw errorAt(`</${closeTag[1]!}> has no matching opening tag`, closeTag.index);\n    }\n  }\n  return roots;\n}\n\nexport default parseDmlToIR;\n\nfunction normalizeText(raw: string, mode: NonNullable<ParseDmlOptions['whitespace']>): string {\n  switch (mode) {\n    case 'preserve':\n      return raw.trim().length === 0 ? '' : raw;\n    case 'collapse':\n      return raw.replace(/\\s+/g, ' ').trim();\n    case 'trim':\n      return raw.trim();\n  }\n}\n","import type { SourceLocation } from '@monimesl/dot-core';\n\nexport interface DmlElementNode {\n  readonly type: 'Element';\n  readonly tag: string;\n  readonly events: Record<string, string>;\n  readonly attributes: Record<string, string>;\n  readonly children: DmlNode[];\n  readonly loc?: SourceLocation;\n}\n\nexport interface DmlTextNode {\n  readonly type: 'Text';\n  readonly content: string;\n  readonly loc?: SourceLocation;\n}\n\nexport type DmlNode = DmlElementNode | DmlTextNode;\n\nexport function isElementNode(node: DmlNode): node is DmlElementNode {\n  return node.type === 'Element';\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@monimesl/dot-dml-parser",
+  "version": "0.1.0-alpha.10",
+  "description": "Dot .dml template parser: markup -> intermediary representation",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monime-lab/dot.git",
+    "directory": "packages/parsers/dml"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "@monimesl/dot-source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "devDependencies": {
+    "publint": "^0.3.24",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.23.0",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.1"
+  },
+  "dependencies": {
+    "htmlparser2": "^12.0.0",
+    "@monimesl/dot-core": "0.1.0-alpha.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "clean": "rimraf dist *.tsbuildinfo"
+  }
+}