fix: pass context local name when setting innerHTML (closes #146)

build/deno-wasm/deno-wasm.d.ts

@@ -7,9 +7,10 @@
 export function parse(html: string): string;
 /**
  * @param {string} html
+ * @param {string} context_local_name
  * @returns {string}
  */
-export function parse_frag(html: string): string;
+export function parse_frag(html: string, context_local_name: string): string;
 
 export type InitInput =
  | RequestInfo
@@ -21,7 +22,13 @@ export type InitInput =
 export interface InitOutput {
  readonly memory: WebAssembly.Memory;
  readonly parse: (a: number, b: number, c: number) => void;
- readonly parse_frag: (a: number, b: number, c: number) => void;
+ readonly parse_frag: (
+ a: number,
+ b: number,
+ c: number,
+ d: number,
+ e: number,
+ ) => void;
  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
  readonly __wbindgen_malloc: (a: number) => number;
  readonly __wbindgen_realloc: (a: number, b: number, c: number) => number;

deno-dom-native.ts

@@ -18,7 +18,7 @@ const _symbols = {
  result: "void",
  },
  deno_dom_parse_frag_sync: {
- parameters: ["buffer", "usize", "buffer"],
+ parameters: ["buffer", "usize", "buffer", "usize", "buffer"],
  result: "void",
  },
  deno_dom_is_big_endian: { parameters: [], result: "u32" },
@@ -74,16 +74,41 @@ const dylibParseFragSync = dylib.symbols.deno_dom_parse_frag_sync.bind(
 const returnBufSizeLenRaw = new ArrayBuffer(usizeBytes * 2);
 const returnBufSizeLen = new Uint8Array(returnBufSizeLenRaw);
 
+type DocumentParser = (
+ srcBuf: Uint8Array,
+ srcLength: number,
+ returnBuf: Uint8Array,
+) => void;
+type FragmentParser = (
+ srcBuf: Uint8Array,
+ srcLength: number,
+ contextLocalNameBuf: Uint8Array,
+ contextLocalNameLength: number,
+ returnBuf: Uint8Array,
+) => void;
+
 function genericParse(
- parser: (
- srcBuf: Uint8Array,
- srcLength: number,
- returnBuf: Uint8Array,
- ) => void,
+ parser: DocumentParser | FragmentParser,
  srcHtml: string,
+ contextLocalName?: string,
 ): string {
  const encodedHtml = utf8Encoder.encode(srcHtml);
- parser(encodedHtml, encodedHtml.length, returnBufSizeLen);
+ if (contextLocalName) {
+ const encodedContextLocalName = utf8Encoder.encode(contextLocalName);
+ (parser as FragmentParser)(
+ encodedHtml,
+ encodedHtml.length,
+ encodedContextLocalName,
+ encodedContextLocalName.length,
+ returnBufSizeLen,
+ );
+ } else {
+ (parser as DocumentParser)(
+ encodedHtml,
+ encodedHtml.length,
+ returnBufSizeLen,
+ );
+ }
 
  const outBufSize = Number(
  new DataView(returnBufSizeLenRaw).getBigUint64(0, !isBigEndian),
@@ -98,8 +123,8 @@ function parse(html: string): string {
  return genericParse(dylibParseSync, html);
 }
 
-function parseFrag(html: string): string {
- return genericParse(dylibParseFragSync, html);
+function parseFrag(html: string, contextLocalName?: string): string {
+ return genericParse(dylibParseFragSync, html, contextLocalName);
 }
 
 // Register parse function

deno-dom-wasm.ts

@@ -2,6 +2,12 @@ import init, { parse, parse_frag } from "./build/deno-wasm/deno-wasm.js";
 import { register } from "./src/parser.ts";
 
 await init();
-register(parse, parse_frag);
+register(
+ parse,
+ parse_frag as unknown as (
+ html: string,
+ context_local_name?: string,
+ ) => string,
+);
 
 export * from "./src/api.ts";

html-parser/cli-test/src/main.rs

@@ -9,13 +9,18 @@ enum Method {
 
 fn main() {
  let mut method = Method::Document;
+ let mut context_local_name = "div".to_string();
 
  for arg in args() {
- match arg.as_str() {
- "fragment" => {
- method = Method::Fragment;
- },
- _ => {},
+ if let Method::Document = method {
+ match arg.as_str() {
+ "fragment" => {
+ method = Method::Fragment;
+ },
+ _ => {},
+ }
+ } else {
+ context_local_name = arg;
  }
  }
 
@@ -25,7 +30,7 @@ fn main() {
  if let Method::Document = method {
  println!("{}", parse(buf));
  } else {
- println!("{}", parse_frag(buf));
+ println!("{}", parse_frag(buf, context_local_name));
  }
 }
 

html-parser/core/src/lib.rs

@@ -37,7 +37,7 @@ pub fn parse(html: String) -> String {
  dom_to_string(len, &dom)
 }
 
-pub fn parse_frag(html: String) -> String {
+pub fn parse_frag(html: String, context_local_name: String) -> String {
  let len = html.len();
  let sink: RcDom = Default::default();
  let parser = parse_fragment(
@@ -46,7 +46,7 @@ pub fn parse_frag(html: String) -> String {
  QualName::new(
  None,
  ns!(html),
- LocalName::from("div"),
+ LocalName::from(context_local_name),
  ),
  vec![],
  );

html-parser/plugin/src/lib.rs

@@ -36,22 +36,32 @@ pub extern "C" fn deno_dom_parse_sync(src_buf: *mut u8, src_len: usize, dest_buf
 }
 
 #[no_mangle]
-pub extern "C" fn deno_dom_parse_frag_sync(src_buf: *mut u8, src_len: usize, dest_buf_size_ptr: *mut usize) {
+pub extern "C" fn deno_dom_parse_frag_sync(
+ src_buf: *mut u8,
+ src_len: usize,
+ context_local_name_buf: *mut u8,
+ context_local_name_len: usize,
+ dest_buf_size_ptr: *mut usize
+) {
  let src_html = unsafe {
  String::from_raw_parts(src_buf, src_len, src_len)
  };
+ let context_local_name = unsafe {
+ String::from_raw_parts(context_local_name_buf, context_local_name_len, context_local_name_len)
+ };
  let dest_buf_meta = unsafe {
  std::slice::from_raw_parts_mut(
  dest_buf_size_ptr,
  std::mem::size_of::<usize>() * 2,
  )
  };
 
- let parsed = Box::new(parse_frag(src_html.clone()));
+ let parsed = Box::new(parse_frag(src_html.clone(), context_local_name.clone()));
  dest_buf_meta[0] = parsed.len();
  dest_buf_meta[1] = Box::into_raw(parsed) as usize;
 
  std::mem::forget(src_html);
+ std::mem::forget(context_local_name);
  std::mem::forget(dest_buf_meta);
 }
 

html-parser/wasm/src/lib.rs

@@ -8,7 +8,7 @@ pub fn parse(html: &str) -> String {
 }
 
 #[wasm_bindgen]
-pub fn parse_frag(html: &str) -> String {
- parse_frag_rs(html.into())
+pub fn parse_frag(html: &str, context_local_name: &str) -> String {
+ parse_frag_rs(html.into(), context_local_name.into())
 }
 

src/deserialize.ts

@@ -13,8 +13,11 @@ export function nodesFromString(html: string): Node {
  return node;
 }
 
-export function fragmentNodesFromString(html: string): Node {
- const parsed = JSON.parse(parseFrag(html));
+export function fragmentNodesFromString(
+ html: string,
+ contextLocalName: string,
+): Node {
+ const parsed = JSON.parse(parseFrag(html, contextLocalName));
  const node = nodeFromArray(parsed, null);
 
  return node;

src/dom/element.ts

@@ -593,7 +593,7 @@ export class Element extends Node {
 
  // Parse HTML into new children
  if (html.length) {
- const parsed = fragmentNodesFromString(html);
+ const parsed = fragmentNodesFromString(html, this.localName);
  for (const child of parsed.childNodes[0].childNodes) {
  mutator.push(child);
  }

src/dom/elements/html-template-element.ts

@@ -89,7 +89,7 @@ export class HTMLTemplateElement extends Element {
 
  // Parse HTML into new children
  if (html.length) {
- const parsed = fragmentNodesFromString(html);
+ const parsed = fragmentNodesFromString(html, this.localName);
  mutator.push(...parsed.childNodes[0].childNodes);
 
  for (const child of content.childNodes) {

src/parser.ts

@@ -1,13 +1,13 @@
 /**
  * Parser interface
  */
-export type Parser = (html: string) => string;
+export type Parser = (html: string, contextLocalName?: string) => string;
 export let parse: Parser = (_html) => {
  console.error("Error: deno-dom: No parser registered");
  Deno.exit(1);
 };
 
-export let parseFrag: Parser = (_html) => {
+export let parseFrag: Parser = (_html, _contextLocalName) => {
  console.error("Error: deno-dom: No parser registered");
  Deno.exit(1);
 };

test/units/Element-set-innerHTML.ts

@@ -15,3 +15,32 @@ Deno.test("setting Element.innerHTML yields children with correct .parentNode's"
 
  assertEquals(child.parentNode, parent, "parentNode is the parent");
 });
+
+Deno.test(
+ "Element.innerHTML includes context",
+ () => {
+ const doc = new DOMParser().parseFromString(
+ `
+ <table><tr id=parent-row></tr></table>
+ <div id=parent-div></div>
+ `,
+ "text/html",
+ )!;
+
+ const parentRow = doc.querySelector("#parent-row")!;
+ parentRow.innerHTML = "<th>This is a header</th>";
+
+ assertEquals(
+ parentRow.innerHTML,
+ "<th>This is a header</th>",
+ );
+
+ const parentDiv = doc.querySelector("#parent-div")!;
+ parentDiv.innerHTML = "<th>This is a header</th>";
+
+ assertEquals(
+ parentDiv.innerHTML,
+ "This is a header",
+ );
+ },
+);