refactor: Use objects for adapters (#484)

packages/parse5-parser-stream/test/utils/parse-chunked.ts

@@ -1,4 +1,4 @@
-import type { ParserOptions } from 'parse5/dist/parser/index.js';
+import type { ParserOptions } from 'parse5';
 import type { TreeAdapterTypeMap } from 'parse5/dist/tree-adapters/interface.js';
 import { ParserStream } from '../../lib/index.js';
 import { makeChunks } from 'parse5-test-utils/utils/common.js';

packages/parse5/lib/parser/index.test.ts

@@ -6,7 +6,6 @@ import type { TreeAdapterTypeMap } from './../tree-adapters/interface.js';
 import { generateParsingTests } from 'parse5-test-utils/utils/generate-parsing-tests.js';
 import { treeAdapters } from 'parse5-test-utils/utils/common.js';
 import { NAMESPACES as NS } from '../common/html.js';
-import { isElementNode } from '../tree-adapters/default.js';
 
 const origParseFragment = Parser.parseFragment;
 
@@ -149,9 +148,9 @@ describe('parser', () => {
             });
 
             const htmlElement = document.childNodes[0];
-            assert.ok(isElementNode(htmlElement));
+            assert.ok(treeAdapters.default.isElementNode(htmlElement));
             const bodyElement = htmlElement.childNodes[1];
-            assert.ok(isElementNode(bodyElement));
+            assert.ok(treeAdapters.default.isElementNode(bodyElement));
             // Expect 5 opened elements; in order: html, head, body, and 2x p
             expect(onItemPush).toHaveBeenCalledTimes(5);
             expect(onItemPush).toHaveBeenNthCalledWith(1, htmlElement);

packages/parse5/lib/parser/index.ts

@@ -1,7 +1,7 @@
 import { TokenHandler, Tokenizer, TokenizerMode } from '../tokenizer/index.js';
 import { OpenElementStack, StackHandler } from './open-element-stack.js';
 import { FormattingElementList, ElementEntry, EntryType } from './formatting-element-list.js';
-import * as defaultTreeAdapter from '../tree-adapters/default.js';
+import { defaultTreeAdapter, DefaultTreeAdapterMap } from '../tree-adapters/default.js';
 import * as doctype from '../common/doctype.js';
 import * as foreignContent from '../common/foreign-content.js';
 import { ERR, ParserErrorHandler } from '../common/error-codes.js';
@@ -111,7 +111,7 @@ export interface ParserOptions<T extends TreeAdapterTypeMap> {
     onParseError?: ParserErrorHandler | null;
 }
 
-const defaultParserOptions = {
+const defaultParserOptions: Required<ParserOptions<DefaultTreeAdapterMap>> = {
     scriptingEnabled: true,
     sourceCodeLocationInfo: false,
     treeAdapter: defaultTreeAdapter,
@@ -135,7 +135,7 @@ export class Parser<T extends TreeAdapterTypeMap> implements TokenHandler, Stack
         this.options = {
             ...defaultParserOptions,
             ...options,
-        };
+        } as Required<ParserOptions<T>>;
 
         this.treeAdapter = this.options.treeAdapter;
         this.onParseError = this.options.onParseError;
@@ -173,7 +173,7 @@ export class Parser<T extends TreeAdapterTypeMap> implements TokenHandler, Stack
         const opts: Required<ParserOptions<T>> = {
             ...defaultParserOptions,
             ...options,
-        };
+        } as Required<ParserOptions<T>>;
 
         //NOTE: use a <template> element as the fragment context if no context element was provided,
         //so we will parse in a "forgiving" manner

packages/parse5/lib/serializer/index.test.ts

@@ -2,7 +2,7 @@ import * as assert from 'node:assert';
 import * as parse5 from 'parse5';
 import { generateSerializerTests } from 'parse5-test-utils/utils/generate-serializer-tests.js';
 import { treeAdapters } from 'parse5-test-utils/utils/common.js';
-import { type Element, isElementNode } from 'parse5/dist/tree-adapters/default';
+import { type Element } from 'parse5/dist/tree-adapters/default.js';
 import { NAMESPACES } from 'parse5/dist/common/html.js';
 
 generateSerializerTests('serializer', 'Serializer', parse5.serialize);
@@ -28,7 +28,7 @@ describe('serializer', () => {
         it('serializes outerHTML correctly', () => {
             const document = parse5.parseFragment('<div><button>Hello</button></div>');
             const div = document.childNodes[0];
-            assert.ok(isElementNode(div));
+            assert.ok(treeAdapters.default.isElementNode(div));
             const html = parse5.serializeOuter(div);
 
             assert.equal(html, '<div><button>Hello</button></div>');
@@ -38,7 +38,7 @@ describe('serializer', () => {
     it('serializes <template> elements inner content', () => {
         const document = parse5.parseFragment('<template><button>Hello</button></template>');
         const template = document.childNodes[0];
-        assert.ok(isElementNode(template));
+        assert.ok(treeAdapters.default.isElementNode(template));
         const html = parse5.serialize(template);
 
         assert.equal(html, '<button>Hello</button>');

packages/parse5/lib/serializer/index.ts

@@ -1,6 +1,6 @@
 import { TAG_NAMES as $, NAMESPACES as NS } from '../common/html.js';
 import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface';
-import * as DefaultTreeAdapter from '../tree-adapters/default.js';
+import { defaultTreeAdapter, type DefaultTreeAdapterMap } from '../tree-adapters/default.js';
 
 //Escaping regexes
 const AMP_REGEX = /&/g;
@@ -63,7 +63,7 @@ export interface SerializerOptions<T extends TreeAdapterTypeMap> {
 
 type InternalOptions<T extends TreeAdapterTypeMap> = Required<SerializerOptions<T>>;
 
-const defaultOpts = { treeAdapter: DefaultTreeAdapter, scriptingEnabled: true };
+const defaultOpts: InternalOptions<DefaultTreeAdapterMap> = { treeAdapter: defaultTreeAdapter, scriptingEnabled: true };
 
 /**
  * Serializes an AST node to an HTML string.
@@ -87,11 +87,11 @@ const defaultOpts = { treeAdapter: DefaultTreeAdapter, scriptingEnabled: true };
  * @param node Node to serialize.
  * @param options Serialization options.
  */
-export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapter.DefaultTreeAdapterMap>(
+export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(
     node: T['parentNode'],
     options?: SerializerOptions<T>
 ): string {
-    const opts = { ...defaultOpts, ...options };
+    const opts = { ...defaultOpts, ...options } as InternalOptions<T>;
 
     if (isVoidElement(node, opts)) {
         return '';
@@ -119,11 +119,11 @@ export function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapter.Defa
  * @param node Node to serialize.
  * @param options Serialization options.
  */
-export function serializeOuter<T extends TreeAdapterTypeMap = DefaultTreeAdapter.DefaultTreeAdapterMap>(
+export function serializeOuter<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(
     node: T['node'],
     options?: SerializerOptions<T>
 ): string {
-    const opts = { ...defaultOpts, ...options };
+    const opts = { ...defaultOpts, ...options } as InternalOptions<T>;
     return serializeNode(node, opts);
 }