@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/nodes/HTMLTableCellElement-impl.js

@@ -0,0 +1,73 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const { asciiLowercase, parseNonNegativeInteger } = require("../helpers/strings");
+const { closest } = require("../helpers/traversal");
+
+function reflectedAttributeClampedToRange(attrValue, min, max, defaultValue = 0) {
+  if (attrValue === null) {
+    return defaultValue;
+  }
+  const parsed = parseNonNegativeInteger(attrValue);
+  if (parsed === null) {
+    return defaultValue;
+  }
+  if (parsed < min) {
+    return min;
+  }
+  if (parsed > max) {
+    return max;
+  }
+  return parsed;
+}
+
+class HTMLTableCellElementImpl extends HTMLElementImpl {
+  get colSpan() {
+    return reflectedAttributeClampedToRange(this.getAttributeNS(null, "colspan"), 1, 1000, 1);
+  }
+
+  set colSpan(V) {
+    this.setAttributeNS(null, "colspan", String(V));
+  }
+
+  get rowSpan() {
+    return reflectedAttributeClampedToRange(this.getAttributeNS(null, "rowspan"), 0, 65534, 1);
+  }
+
+  set rowSpan(V) {
+    this.setAttributeNS(null, "rowspan", String(V));
+  }
+
+  get cellIndex() {
+    const tr = closest(this, "tr");
+    if (tr === null) {
+      return -1;
+    }
+
+    return tr.cells.indexOf(this);
+  }
+
+  get scope() {
+    let value = this.getAttributeNS(null, "scope");
+    if (value === null) {
+      return "";
+    }
+
+    // Enumerated attribute is matched ASCII-case-insensitively.
+    value = asciiLowercase(value);
+    if (value === "row" || value === "col" || value === "rowgroup" || value === "colgroup") {
+      return value;
+    }
+
+    return "";
+  }
+
+  set scope(V) {
+    this.setAttributeNS(null, "scope", V);
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableCellElementImpl
+};

package/lib/jsdom/living/nodes/HTMLTableColElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLTableColElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLTableColElementImpl
+};

package/lib/jsdom/living/nodes/HTMLTableElement-impl.js

@@ -0,0 +1,236 @@
+"use strict";
+const DOMException = require("../../../generated/idl/DOMException");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { HTML_NS } = require("../helpers/namespaces");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { firstChildWithLocalName, childrenByLocalName } = require("../helpers/traversal");
+const HTMLCollection = require("../../../generated/idl/HTMLCollection");
+const NODE_TYPE = require("../node-type");
+
+function tHeadInsertionPoint(table) {
+  const iterator = domSymbolTree.childrenIterator(table);
+  for (const child of iterator) {
+    if (child.nodeType !== NODE_TYPE.ELEMENT_NODE) {
+      continue;
+    }
+
+    if (child._namespaceURI !== HTML_NS || (child._localName !== "caption" && child._localName !== "colgroup")) {
+      return child;
+    }
+  }
+
+  return null;
+}
+
+class HTMLTableElementImpl extends HTMLElementImpl {
+  get caption() {
+    return firstChildWithLocalName(this, "caption");
+  }
+
+  set caption(value) {
+    const currentCaption = this.caption;
+    if (currentCaption !== null) {
+      this.removeChild(currentCaption);
+    }
+
+    if (value !== null) {
+      const insertionPoint = this.firstChild;
+      this.insertBefore(value, insertionPoint);
+    }
+  }
+
+  get tHead() {
+    return firstChildWithLocalName(this, "thead");
+  }
+
+  set tHead(value) {
+    if (value !== null && value._localName !== "thead") {
+      throw DOMException.create(this._globalObject, [
+        "Cannot set a non-thead element as a table header",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    const currentHead = this.tHead;
+    if (currentHead !== null) {
+      this.removeChild(currentHead);
+    }
+
+    if (value !== null) {
+      const insertionPoint = tHeadInsertionPoint(this);
+      this.insertBefore(value, insertionPoint);
+    }
+  }
+
+  get tFoot() {
+    return firstChildWithLocalName(this, "tfoot");
+  }
+
+  set tFoot(value) {
+    if (value !== null && value._localName !== "tfoot") {
+      throw DOMException.create(this._globalObject, [
+        "Cannot set a non-tfoot element as a table footer",
+        "HierarchyRequestError"
+      ]);
+    }
+
+    const currentFoot = this.tFoot;
+    if (currentFoot !== null) {
+      this.removeChild(currentFoot);
+    }
+
+    if (value !== null) {
+      this.appendChild(value);
+    }
+  }
+
+  get rows() {
+    if (!this._rows) {
+      this._rows = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => {
+          const headerRows = [];
+          const bodyRows = [];
+          const footerRows = [];
+
+          const iterator = domSymbolTree.childrenIterator(this);
+          for (const child of iterator) {
+            if (child.nodeType !== NODE_TYPE.ELEMENT_NODE || child._namespaceURI !== HTML_NS) {
+              continue;
+            }
+
+            if (child._localName === "thead") {
+              headerRows.push(...childrenByLocalName(child, "tr"));
+            } else if (child._localName === "tbody") {
+              bodyRows.push(...childrenByLocalName(child, "tr"));
+            } else if (child._localName === "tfoot") {
+              footerRows.push(...childrenByLocalName(child, "tr"));
+            } else if (child._localName === "tr") {
+              bodyRows.push(child);
+            }
+          }
+
+          return [...headerRows, ...bodyRows, ...footerRows];
+        }
+      });
+    }
+    return this._rows;
+  }
+
+  get tBodies() {
+    if (!this._tBodies) {
+      this._tBodies = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => childrenByLocalName(this, "tbody")
+      });
+    }
+    return this._tBodies;
+  }
+
+  createTBody() {
+    const el = this._ownerDocument.createElement("TBODY");
+
+    const tbodies = childrenByLocalName(this, "tbody");
+    const insertionPoint = tbodies[tbodies.length - 1];
+
+    if (insertionPoint) {
+      this.insertBefore(el, insertionPoint.nextSibling);
+    } else {
+      this.appendChild(el);
+    }
+    return el;
+  }
+
+  createTHead() {
+    let el = this.tHead;
+    if (!el) {
+      el = this.tHead = this._ownerDocument.createElement("THEAD");
+    }
+    return el;
+  }
+
+  deleteTHead() {
+    this.tHead = null;
+  }
+
+  createTFoot() {
+    let el = this.tFoot;
+    if (!el) {
+      el = this.tFoot = this._ownerDocument.createElement("TFOOT");
+    }
+    return el;
+  }
+
+  deleteTFoot() {
+    this.tFoot = null;
+  }
+
+  createCaption() {
+    let el = this.caption;
+    if (!el) {
+      el = this.caption = this._ownerDocument.createElement("CAPTION");
+    }
+    return el;
+  }
+
+  deleteCaption() {
+    const c = this.caption;
+    if (c) {
+      c.parentNode.removeChild(c);
+    }
+  }
+
+  insertRow(index) {
+    if (index < -1 || index > this.rows.length) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot insert a row at an index that is less than -1 or greater than the number of existing rows",
+        "IndexSizeError"
+      ]);
+    }
+
+    const tr = this._ownerDocument.createElement("tr");
+
+    if (this.rows.length === 0 && this.tBodies.length === 0) {
+      const tBody = this._ownerDocument.createElement("tbody");
+      tBody.appendChild(tr);
+      this.appendChild(tBody);
+    } else if (this.rows.length === 0) {
+      const tBody = this.tBodies.item(this.tBodies.length - 1);
+      tBody.appendChild(tr);
+    } else if (index === -1 || index === this.rows.length) {
+      const tSection = this.rows.item(this.rows.length - 1).parentNode;
+      tSection.appendChild(tr);
+    } else {
+      const beforeTR = this.rows.item(index);
+      const tSection = beforeTR.parentNode;
+      tSection.insertBefore(tr, beforeTR);
+    }
+
+    return tr;
+  }
+
+  deleteRow(index) {
+    const rowLength = this.rows.length;
+    if (index < -1 || index >= rowLength) {
+      throw DOMException.create(this._globalObject, [
+        `Cannot delete a row at index ${index}, where no row exists`,
+        "IndexSizeError"
+      ]);
+    }
+
+    if (index === -1) {
+      if (rowLength === 0) {
+        return;
+      }
+
+      index = rowLength - 1;
+    }
+
+    const tr = this.rows.item(index);
+    tr.parentNode.removeChild(tr);
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableElementImpl
+};

package/lib/jsdom/living/nodes/HTMLTableRowElement-impl.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const DOMException = require("../../../generated/idl/DOMException");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const HTMLCollection = require("../../../generated/idl/HTMLCollection");
+const { HTML_NS } = require("../helpers/namespaces");
+const { childrenByLocalNames } = require("../helpers/traversal");
+const { domSymbolTree } = require("../helpers/internal-constants");
+
+const cellLocalNames = new Set(["td", "th"]);
+
+class HTMLTableRowElementImpl extends HTMLElementImpl {
+  get cells() {
+    if (!this._cells) {
+      this._cells = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => childrenByLocalNames(this, cellLocalNames)
+      });
+    }
+    return this._cells;
+  }
+
+  get rowIndex() {
+    const parent = this.parentElement;
+    if (parent === null || parent.namespaceURI !== HTML_NS) {
+      return -1;
+    }
+
+    let tableElement = parent;
+    if (parent.localName === "thead" || parent.localName === "tbody" || parent.localName === "tfoot") {
+      tableElement = parent.parentElement;
+    }
+    if (tableElement === null || tableElement.namespaceURI !== HTML_NS || tableElement.localName !== "table") {
+      return -1;
+    }
+
+    return tableElement.rows.indexOf(this);
+  }
+
+  get sectionRowIndex() {
+    const parent = domSymbolTree.parent(this);
+    if (parent === null) {
+      return -1;
+    }
+
+    const { rows } = parent;
+    if (!rows) {
+      return -1;
+    }
+
+    return rows.indexOf(this);
+  }
+
+  insertCell(index) {
+    const td = this._ownerDocument.createElement("TD");
+    const { cells } = this;
+    if (index < -1 || index > cells.length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    if (index === -1 || index === cells.length) {
+      this._append(td);
+    } else {
+      const ref = cells.item(index);
+      this._insert(td, ref);
+    }
+    return td;
+  }
+
+  deleteCell(index) {
+    const { cells } = this;
+    if (index < -1 || index >= cells.length) {
+      throw DOMException.create(this._globalObject, ["The index is not in the allowed range.", "IndexSizeError"]);
+    }
+    if (index === -1) {
+      if (cells.length === 0) {
+        return;
+      }
+
+      index = cells.length - 1;
+    }
+    const td = cells.item(index);
+    this._remove(td);
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableRowElementImpl
+};

package/lib/jsdom/living/nodes/HTMLTableSectionElement-impl.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { childrenByLocalName } = require("../helpers/traversal");
+const HTMLCollection = require("../../../generated/idl/HTMLCollection");
+const DOMException = require("../../../generated/idl/DOMException");
+
+class HTMLTableSectionElementImpl extends HTMLElementImpl {
+  get rows() {
+    if (!this._rows) {
+      this._rows = HTMLCollection.createImpl(this._globalObject, [], {
+        element: this,
+        query: () => childrenByLocalName(this, "tr")
+      });
+    }
+    return this._rows;
+  }
+
+  insertRow(index) {
+    if (index < -1 || index > this.rows.length) {
+      throw DOMException.create(this._globalObject, [
+        "Cannot insert a row at an index that is less than -1 or greater than the number of existing rows",
+        "IndexSizeError"
+      ]);
+    }
+
+    const tr = this._ownerDocument.createElement("tr");
+
+    if (index === -1 || index === this.rows.length) {
+      this._append(tr);
+    } else {
+      const beforeTR = this.rows.item(index);
+      this._insert(tr, beforeTR);
+    }
+
+    return tr;
+  }
+
+  deleteRow(index) {
+    if (index < -1 || index >= this.rows.length) {
+      throw DOMException.create(this._globalObject, [
+        `Cannot delete a row at index ${index}, where no row exists`,
+        "IndexSizeError"
+      ]);
+    }
+
+    if (index === -1) {
+      if (this.rows.length > 0) {
+        const tr = this.rows.item(this.rows.length - 1);
+        this._remove(tr);
+      }
+    } else {
+      const tr = this.rows.item(index);
+      this._remove(tr);
+    }
+  }
+}
+
+module.exports = {
+  implementation: HTMLTableSectionElementImpl
+};

package/lib/jsdom/living/nodes/HTMLTemplateElement-impl.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+const Document = require("../../../generated/idl/Document");
+const DocumentFragment = require("../../../generated/idl/DocumentFragment");
+
+const { cloningSteps, domSymbolTree } = require("../helpers/internal-constants");
+const { clone } = require("../node");
+
+class HTMLTemplateElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    const doc = this._appropriateTemplateContentsOwnerDocument(this._ownerDocument);
+    this._templateContents = DocumentFragment.createImpl(this._globalObject, [], {
+      ownerDocument: doc,
+      host: this
+    });
+  }
+
+  // https://html.spec.whatwg.org/multipage/scripting.html#appropriate-template-contents-owner-document
+  _appropriateTemplateContentsOwnerDocument(doc) {
+    if (!doc._isInertTemplateDocument) {
+      if (doc._associatedInertTemplateDocument === undefined) {
+        const newDoc = Document.createImpl(this._globalObject, [], {
+          options: {
+            parsingMode: doc._parsingMode,
+            encoding: doc._encoding
+          }
+        });
+        newDoc._isInertTemplateDocument = true;
+
+        doc._associatedInertTemplateDocument = newDoc;
+      }
+
+      doc = doc._associatedInertTemplateDocument;
+    }
+
+    return doc;
+  }
+
+  // https://html.spec.whatwg.org/multipage/scripting.html#template-adopting-steps
+  _adoptingSteps() {
+    const doc = this._appropriateTemplateContentsOwnerDocument(this._ownerDocument);
+    doc._adoptNode(this._templateContents);
+  }
+
+  get content() {
+    return this._templateContents;
+  }
+
+  [cloningSteps](copy, node, document, cloneChildren) {
+    if (!cloneChildren) {
+      return;
+    }
+
+    for (const child of domSymbolTree.childrenIterator(node._templateContents)) {
+      const childCopy = clone(child, copy._templateContents._ownerDocument, true);
+      copy._templateContents.appendChild(childCopy);
+    }
+  }
+}
+
+module.exports = {
+  implementation: HTMLTemplateElementImpl
+};