xml-to-html-converter 0.1.2 → 0.1.3

package/README.md

@@ -1,6 +1,6 @@
 # xml-to-html-converter
 
-![version](https://img.shields.io/badge/version-0.1.1-blue)
+![version](https://img.shields.io/npm/v/xml-to-html-converter)
 ![node version](https://img.shields.io/node/v/xml-to-html-converter)
 ![zero dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)
 ![XML](https://img.shields.io/badge/input-XML-orange)
@@ -158,4 +158,4 @@ Node.js `>=18.0.0`
 
 ---
 
-![license](https://img.shields.io/badge/license-ISC-green)
+![license](https://img.shields.io/npm/l/xml-to-html-converter)

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+interface DocumentNode {
+    type: 'document';
+    children: Node[];
+}
+interface ElementNode {
+    type: 'element';
+    tag: string;
+    attributes: Record<string, string>;
+    children: Node[];
+    malformed?: true;
+}
+interface TextNode {
+    type: 'text';
+    value: string;
+}
+interface CommentNode {
+    type: 'comment';
+    value: string;
+}
+interface CDataNode {
+    type: 'cdata';
+    value: string;
+}
+interface ProcessingInstructionNode {
+    type: 'processing-instruction';
+    target: string;
+    attributes: Record<string, string>;
+}
+interface MalformedNode {
+    type: 'malformed';
+    raw: string;
+    malformed: true;
+}
+type Node = ElementNode | TextNode | CommentNode | CDataNode | ProcessingInstructionNode | MalformedNode;
+declare function parse(xml: string): DocumentNode;
+
+declare const TokenType: {
+    readonly PROCESSING_INSTRUCTION: "processing-instruction";
+    readonly ELEMENT_OPEN: "element-open";
+    readonly ELEMENT_CLOSE: "element-close";
+    readonly SELF_CLOSING: "self-closing";
+    readonly TEXT: "text";
+    readonly COMMENT: "comment";
+    readonly CDATA: "cdata";
+    readonly MALFORMED: "malformed";
+};
+type TokenTypeValue = typeof TokenType[keyof typeof TokenType];
+interface ProcessingInstructionToken {
+    type: typeof TokenType.PROCESSING_INSTRUCTION;
+    target: string;
+    attributes: Record<string, string>;
+}
+interface ElementOpenToken {
+    type: typeof TokenType.ELEMENT_OPEN;
+    tag: string;
+    attributes: Record<string, string>;
+}
+interface ElementCloseToken {
+    type: typeof TokenType.ELEMENT_CLOSE;
+    tag: string;
+}
+interface SelfClosingToken {
+    type: typeof TokenType.SELF_CLOSING;
+    tag: string;
+    attributes: Record<string, string>;
+}
+interface TextToken {
+    type: typeof TokenType.TEXT;
+    value: string;
+}
+interface CommentToken {
+    type: typeof TokenType.COMMENT;
+    value: string;
+}
+interface CDataToken {
+    type: typeof TokenType.CDATA;
+    value: string;
+}
+interface MalformedToken {
+    type: typeof TokenType.MALFORMED;
+    raw: string;
+}
+type Token = ProcessingInstructionToken | ElementOpenToken | ElementCloseToken | SelfClosingToken | TextToken | CommentToken | CDataToken | MalformedToken;
+
+export { type CDataNode, type CommentNode, type DocumentNode, type ElementNode, type MalformedNode, type Node, type ProcessingInstructionNode, type TextNode, type Token, type TokenTypeValue, parse };

package/dist/index.js

@@ -0,0 +1,113 @@
+// src/tokenizer.ts
+var TokenType = {
+  PROCESSING_INSTRUCTION: "processing-instruction",
+  ELEMENT_OPEN: "element-open",
+  ELEMENT_CLOSE: "element-close",
+  SELF_CLOSING: "self-closing",
+  TEXT: "text",
+  COMMENT: "comment",
+  CDATA: "cdata",
+  MALFORMED: "malformed"
+};
+var WHITESPACE = /\s/;
+function parseAttributes(raw) {
+  const attributes = {};
+  const pattern = /(\S+?)\s*=\s*["']([^"']*)["']/g;
+  let match;
+  while ((match = pattern.exec(raw)) !== null) {
+    attributes[match[1]] = match[2];
+  }
+  return attributes;
+}
+function nextToken(xml, position) {
+  if (xml[position] !== "<") {
+    const end2 = xml.indexOf("<", position);
+    const value = xml.slice(position, end2 === -1 ? xml.length : end2);
+    return { token: value.trim() ? { type: TokenType.TEXT, value } : null, end: end2 === -1 ? xml.length : end2 };
+  }
+  const next = xml[position + 1];
+  if (next === "?") {
+    const closeIndex = xml.indexOf("?>", position);
+    if (closeIndex === -1) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
+    const end2 = closeIndex + 2;
+    const inner2 = xml.slice(position + 2, end2 - 2).trim();
+    const space2 = inner2.search(WHITESPACE);
+    return { token: { type: TokenType.PROCESSING_INSTRUCTION, target: space2 === -1 ? inner2 : inner2.slice(0, space2), attributes: parseAttributes(inner2) }, end: end2 };
+  }
+  if (next === "!" && xml[position + 2] === "-") {
+    const closeIndex = xml.indexOf("-->", position);
+    if (closeIndex === -1) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
+    const end2 = closeIndex + 3;
+    return { token: { type: TokenType.COMMENT, value: xml.slice(position + 4, end2 - 3) }, end: end2 };
+  }
+  if (next === "!" && xml[position + 2] === "[") {
+    const closeIndex = xml.indexOf("]]>", position);
+    if (closeIndex === -1) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
+    const end2 = closeIndex + 3;
+    return { token: { type: TokenType.CDATA, value: xml.slice(position + 9, end2 - 3) }, end: end2 };
+  }
+  const end = xml.indexOf(">", position) + 1;
+  if (!end) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
+  const raw = xml.slice(position + 1, end - 1).trim();
+  if (raw[0] === "/") return { token: { type: TokenType.ELEMENT_CLOSE, tag: raw.slice(1).trim() }, end };
+  const selfClosing = raw[raw.length - 1] === "/";
+  const inner = selfClosing ? raw.slice(0, -1).trim() : raw;
+  const space = inner.search(WHITESPACE);
+  const tag = space === -1 ? inner : inner.slice(0, space);
+  const type = selfClosing ? TokenType.SELF_CLOSING : TokenType.ELEMENT_OPEN;
+  return { token: { type, tag, attributes: parseAttributes(inner) }, end };
+}
+function tokenize(xml) {
+  const tokens = [];
+  let position = 0;
+  while (position < xml.length) {
+    const { token, end } = nextToken(xml, position);
+    if (token) tokens.push(token);
+    position = end;
+  }
+  return tokens;
+}
+
+// src/parser.ts
+function parse(xml) {
+  const tokens = tokenize(xml);
+  const cursor = { position: 0 };
+  const children = collectChildren(tokens, cursor, null);
+  return { type: "document", children };
+}
+function collectChildren(tokens, cursor, parentTag) {
+  const children = [];
+  while (cursor.position < tokens.length) {
+    const token = tokens[cursor.position];
+    cursor.position++;
+    if (token.type === TokenType.ELEMENT_CLOSE) {
+      if (token.tag === parentTag) return children;
+      children.push({ type: "malformed", raw: `</${token.tag}>`, malformed: true });
+      continue;
+    }
+    if (token.type === TokenType.ELEMENT_OPEN) {
+      const node = { type: "element", tag: token.tag, attributes: token.attributes, children: collectChildren(tokens, cursor, token.tag) };
+      children.push(node);
+      continue;
+    }
+    children.push(tokenToNode(token));
+  }
+  if (parentTag !== null) {
+    children.forEach((child) => {
+      child.malformed = true;
+    });
+  }
+  return children;
+}
+function tokenToNode(token) {
+  if (token.type === TokenType.TEXT) return { type: "text", value: token.value };
+  if (token.type === TokenType.COMMENT) return { type: "comment", value: token.value };
+  if (token.type === TokenType.CDATA) return { type: "cdata", value: token.value };
+  if (token.type === TokenType.SELF_CLOSING) return { type: "element", tag: token.tag, attributes: token.attributes, children: [] };
+  if (token.type === TokenType.PROCESSING_INSTRUCTION) return { type: "processing-instruction", target: token.target, attributes: token.attributes };
+  if (token.type === TokenType.MALFORMED) return { type: "malformed", raw: token.raw, malformed: true };
+  return { type: "malformed", raw: `<${token.tag}>`, malformed: true };
+}
+export {
+  parse
+};

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "xml-to-html-converter",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Zero dependency XML to HTML converter for Node environments",
   "type": "module",
-  "main": "src/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "files": [
-    "src/"
+    "dist/"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "scripts": {
-    "test": "node --test tests/tokenizer.test.js tests/parser.test.js",
-    "coverage": "node --experimental-test-coverage --test tests/tokenizer.test.js tests/parser.test.js"
+    "build": "tsup",
+    "test": "vitest run",
+    "coverage": "vitest run --coverage"
   },
   "keywords": [
     "xml",
@@ -24,8 +29,8 @@
     "parser",
     "tree"
   ],
-  "author": "",
-  "license": "ISC",
+  "author": "Jeffery W. Patterson",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jpatterson933/xml-to-html-converter.git"
@@ -33,5 +38,12 @@
   "bugs": {
     "url": "https://github.com/jpatterson933/xml-to-html-converter/issues"
   },
-  "homepage": "https://github.com/jpatterson933/xml-to-html-converter#readme"
+  "homepage": "https://github.com/jpatterson933/xml-to-html-converter#readme",
+  "devDependencies": {
+    "@types/node": "^25.3.2",
+    "@vitest/coverage-v8": "^4.0.18",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
 }

package/src/index.js

@@ -1,3 +0,0 @@
-import { parse } from './parser.js';
-
-export { parse };

package/src/parser.js

@@ -1,48 +0,0 @@
-import { tokenize, TokenType } from './tokenizer.js';
-
-function parse(xml) {
-  const tokens = tokenize(xml);
-  const cursor = { position: 0 };
-  const children = collectChildren(tokens, cursor, null);
-  return { type: 'document', children };
-}
-
-function collectChildren(tokens, cursor, parentTag) {
-  const children = [];
-
-  while (cursor.position < tokens.length) {
-    const token = tokens[cursor.position];
-    cursor.position++;
-
-    if (token.type === TokenType.ELEMENT_CLOSE) {
-      if (token.tag === parentTag) return children;
-      children.push({ type: 'malformed', raw: `</${token.tag}>`, malformed: true });
-      continue;
-    }
-
-    if (token.type === TokenType.ELEMENT_OPEN) {
-      const node = { type: 'element', tag: token.tag, attributes: token.attributes, children: collectChildren(tokens, cursor, token.tag) };
-      children.push(node);
-      continue;
-    }
-
-    children.push(tokenToNode(token));
-  }
-
-  if (parentTag !== null) {
-    children.forEach(child => { child.malformed = true; });
-  }
-
-  return children;
-}
-
-function tokenToNode(token) {
-  if (token.type === TokenType.TEXT) return { type: 'text', value: token.value };
-  if (token.type === TokenType.COMMENT) return { type: 'comment', value: token.value };
-  if (token.type === TokenType.CDATA) return { type: 'cdata', value: token.value };
-  if (token.type === TokenType.SELF_CLOSING) return { type: 'element', tag: token.tag, attributes: token.attributes, children: [] };
-  if (token.type === TokenType.PROCESSING_INSTRUCTION) return { type: 'processing-instruction', target: token.target, attributes: token.attributes };
-  return { type: 'malformed', raw: token.raw, malformed: true };
-}
-
-export { parse };

package/src/tokenizer.js

@@ -1,85 +0,0 @@
-const TokenType = {
-  PROCESSING_INSTRUCTION: 'processing-instruction',
-  ELEMENT_OPEN: 'element-open',
-  ELEMENT_CLOSE: 'element-close',
-  SELF_CLOSING: 'self-closing',
-  TEXT: 'text',
-  COMMENT: 'comment',
-  CDATA: 'cdata',
-  MALFORMED: 'malformed',
-};
-
-const WHITESPACE = /\s/;
-const ATTRIBUTE_PATTERN = /(\S+?)\s*=\s*["']([^"']*)["']/g;
-
-function parseAttributes(raw) {
-  const attributes = {};
-  ATTRIBUTE_PATTERN.lastIndex = 0;
-  let match;
-  while ((match = ATTRIBUTE_PATTERN.exec(raw)) !== null) {
-    attributes[match[1]] = match[2];
-  }
-  return attributes;
-}
-
-function nextToken(xml, position) {
-  if (xml[position] !== '<') {
-    const end = xml.indexOf('<', position);
-    const value = xml.slice(position, end === -1 ? xml.length : end);
-    return { token: value.trim() ? { type: TokenType.TEXT, value } : null, end: end === -1 ? xml.length : end };
-  }
-
-  const next = xml[position + 1];
-
-  if (next === '?') {
-    const closeIndex = xml.indexOf('?>', position);
-    if (closeIndex === -1) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
-    const end = closeIndex + 2;
-    const inner = xml.slice(position + 2, end - 2).trim();
-    const space = inner.search(WHITESPACE);
-    return { token: { type: TokenType.PROCESSING_INSTRUCTION, target: space === -1 ? inner : inner.slice(0, space), attributes: parseAttributes(inner) }, end };
-  }
-
-  if (next === '!' && xml[position + 2] === '-') {
-    const closeIndex = xml.indexOf('-->', position);
-    if (closeIndex === -1) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
-    const end = closeIndex + 3;
-    return { token: { type: TokenType.COMMENT, value: xml.slice(position + 4, end - 3) }, end };
-  }
-
-  if (next === '!' && xml[position + 2] === '[') {
-    const closeIndex = xml.indexOf(']]>', position);
-    if (closeIndex === -1) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
-    const end = closeIndex + 3;
-    return { token: { type: TokenType.CDATA, value: xml.slice(position + 9, end - 3) }, end };
-  }
-
-  const end = xml.indexOf('>', position) + 1;
-  if (!end) return { token: { type: TokenType.MALFORMED, raw: xml.slice(position) }, end: xml.length };
-
-  const raw = xml.slice(position + 1, end - 1).trim();
-  if (raw[0] === '/') return { token: { type: TokenType.ELEMENT_CLOSE, tag: raw.slice(1).trim() }, end };
-
-  const selfClosing = raw[raw.length - 1] === '/';
-  const inner = selfClosing ? raw.slice(0, -1).trim() : raw;
-  const space = inner.search(WHITESPACE);
-  const tag = space === -1 ? inner : inner.slice(0, space);
-  const type = selfClosing ? TokenType.SELF_CLOSING : TokenType.ELEMENT_OPEN;
-
-  return { token: { type, tag, attributes: parseAttributes(inner) }, end };
-}
-
-function tokenize(xml) {
-  const tokens = [];
-  let position = 0;
-
-  while (position < xml.length) {
-    const { token, end } = nextToken(xml, position);
-    if (token) tokens.push(token);
-    position = end;
-  }
-
-  return tokens;
-}
-
-export { tokenize, TokenType };