abstract-document 20.0.4 → 20.1.1

package/src/abstract-document-exporters/docx/xml-writer.ts

@@ -1,21 +1,3 @@
-// interface XmlElement {
-//   localName: string,
-//   ns: string | undefined,
-//   prefix: string | undefined,
-//   attributes: Array<XmlAttribute>
-//   parent: XmlElement,
-//   children: Array<XmlElement>
-// }
-
-// interface XmlAttribute {
-//   localName: string,
-//   value: string,
-//   ns: string | undefined,
-//   prefix: string | undefined
-// }
-
-//tslint:disable
-
 interface XmlNamespaceDictionary {
   [ns: string]: string;
 }
@@ -28,307 +10,320 @@ interface XmlElementContext {
 
 type XmlWriterState = "Start" | "Prolog" | "Element" | "Content" | "Error" | "Closed";
 
-export class XmlWriter {
-  private static readonly quoteChar = '"';
-  private readonly _encoding: string = "utf-8";
-  private readonly _indent: number = 2;
-
-  private _xml: string = "";
-  private _state: XmlWriterState = "Start";
-  private _contextStack: Array<XmlElementContext> = [];
-
-  WriteStartDocument(standalone?: boolean): void {
-    try {
-      // tslint:disable-next-line:no-this
-      if (this._state === "Start" || this._state === "Prolog") {
-        let bufBld: string = "";
-        bufBld += "version=" + XmlWriter.quoteChar + "1.0" + XmlWriter.quoteChar;
-        if (this._encoding != null) {
-          bufBld += ` encoding=${XmlWriter.quoteChar}${this._encoding}${XmlWriter.quoteChar}`;
-        }
-        if (standalone) {
-          const standAlone = standalone ? "yes" : "no";
-          bufBld += ` standalone=${XmlWriter.quoteChar}${standAlone}${XmlWriter.quoteChar}`;
-        }
-        this.writeIndent(this._state !== "Start");
-        const xmlProcessingIntruction = `<?xml ${bufBld}?>`;
-        this.write(xmlProcessingIntruction);
-      } else {
-        this.throwInvalidState();
-      }
-      // Set next state
-      this._state = "Prolog";
-    } catch (e) {
-      this._state = "Error";
-      throw e;
-    }
-  }
-
-  WriteComment(text: string): void {
-    try {
-      if (this._state === "Prolog" || this._state === "Content") {
-        if (text && (text.indexOf("--") >= 0 || (text.length != 0 && text[text.length - 1] == "-"))) {
-          throw new Error("Xml_InvalidCommentChars");
-        }
-        text = text || "";
-        this.writeIndent();
-        this.write(`<!--${text}-->`);
-      } else {
-        this.throwInvalidState();
-      }
-      // Set next state
-      // For XML-comments this case the next state should be the same as the previous one!
-    } catch (e) {
-      this._state = "Error";
-      throw e;
-    }
-  }
-
-  WriteStartElement(localName: string): void;
-  WriteStartElement(localName: string, ns: string): void;
-  WriteStartElement(localName: string, ns: string, prefix: string): void;
-  WriteStartElement(localName: string, ns?: string, prefix?: string): void {
-    try {
-      if (
-        this._state === "Start" ||
-        this._state === "Prolog" ||
-        this._state === "Element" ||
-        this._state === "Content"
-      ) {
-        if (this._state === "Element") {
-          // Close previous start-element
-          this.completeStartElement(false, this.peekContextStack().namespaces);
-        }
+export interface XmlWriter {
+  WriteStartDocument: (standalone?: boolean) => void;
+  WriteComment: (text: string) => void;
+  WriteStartElement: (localName: string, ns?: string, prefix?: string) => void;
+  WriteString: (text: string) => void;
+  WriteElementString: (localName: string, value: string, ns: string, prefix: string) => void;
+  WriteAttributeString: (localName: string, value: string, ns?: string, prefix?: string) => void;
+  WriteEndElement: () => void;
+  Flush: () => void;
+  close: () => void;
+  getXml: () => string;
+}
 
-        // Push new element-context to stack
-        const elementName: string = XmlWriter.getPrefixedName(localName, prefix);
-        this._contextStack.push({
-          elementName,
-          namespaces: {},
-          contentStringWritten: false,
-        });
+export function createXmlWriter(): XmlWriter {
+  const quoteChar = '"';
+  const encoding = "utf-8";
+  const indentSize = 2;
 
-        this.writeIndent(this._state !== "Start");
-        this.write("<" + elementName);
+  let xml = "";
+  let state: XmlWriterState = "Start";
+  const contextStack: Array<XmlElementContext> = [];
 
-        if (ns) {
-          this.addNamespace(ns, prefix);
-        }
-      } else {
-        this.throwInvalidState();
-      }
-      // Set next state
-      this._state = "Element";
-    } catch (e) {
-      this._state = "Error";
-      throw e;
-    }
+  function write(text: string): void {
+    xml += text;
   }
 
-  WriteString(text: string): void {
-    try {
-      if (this._state === "Content" || this._state === "Element") {
-        if (this._state === "Element") {
-          this.completeStartElement(false, this.peekContextStack().namespaces);
-        }
-
-        // Flag that content string has been written
-        this.peekContextStack().contentStringWritten = true;
-
-        this.write(text);
-      } else {
-        this.throwInvalidState();
-      }
-      // Set next state
-      this._state = "Content";
-    } catch (e) {
-      this._state = "Error";
-      throw e;
-    }
+  function peekContextStack(): XmlElementContext {
+    return contextStack[contextStack.length - 1];
   }
 
-  WriteElementString(localName: string, value: string, ns: string, prefix: string): void {
-    this.WriteStartElement(localName, ns, prefix);
-    if (value && value.length > 0) this.WriteString(value);
-    this.WriteEndElement();
+  function throwInvalidState(): void {
+    throw new Error(`Invalid state '${state}'.`);
   }
 
-  WriteAttributeString(localName: string, value: string): void;
-  WriteAttributeString(localName: string, value: string, ns: string): void;
-  WriteAttributeString(localName: string, value: string, ns: string, prefix: string): void;
-  WriteAttributeString(localName: string, value: string, ns?: string, prefix?: string): void {
-    try {
-      if (this._state === "Element") {
-        if (ns) {
-          // Seems like a prefix is always invented for attributes if not provided
-          // (but for elements it is OK to have blank prefix)
-          if (!prefix || prefix.length === 0) {
-            prefix = this.getPrefixFromAncestors(ns);
-            if (!prefix) {
-              prefix = XmlWriter.generatePrefix(this.peekContextStack().namespaces);
-            }
-          }
-          this.addNamespace(ns, prefix);
-        }
-        const attributeName: string = XmlWriter.getPrefixedName(localName, prefix);
-        this.write(` ${attributeName}=${XmlWriter.quoteChar}${value}${XmlWriter.quoteChar}`);
-      } else {
-        this.throwInvalidState();
+  function generatePrefix(namespaces: XmlNamespaceDictionary): string {
+    let i = 1;
+    while (i < 100) {
+      if (!Object.hasOwn(namespaces, "p" + i)) {
+        break;
       }
-      // Set next state
-      this._state = "Element";
-    } catch (e) {
-      this._state = "Error";
-      throw e;
+      i++;
     }
+    return "p" + i;
   }
 
-  WriteEndElement(): void {
-    try {
-      if (this._state === "Content" || this._state === "Element") {
-        // const context = this._contextStack.pop() as XmlElementContext;
-        const context = this.peekContextStack();
-        // Only close in itself if no content
-        if (this._state === "Element") {
-          this.completeStartElement(true, context.namespaces);
-        } else {
-          // Do not indent if there is text content written since
-          // the indention would be included in the actual text content
-          if (!context.contentStringWritten) this.writeIndent();
-          this.write(`</${context.elementName}>`);
-        }
-        this._contextStack.pop();
-      } else {
-        this.throwInvalidState();
-      }
-      // Set next state
-      if (this._contextStack.length == 0) {
-        this._state = "Closed";
-      } else {
-        this._state = "Content";
-      }
-    } catch (e) {
-      this._state = "Error";
-      throw e;
+  function getPrefixedName(localName: string, prefix: string | undefined): string {
+    if (prefix) {
+      return `${prefix}:${localName}`;
+    } else {
+      // oxlint-disable-next-line typescript/no-unnecessary-template-expression
+      return `${localName}`;
     }
   }
 
-  Flush(): void {
-    this.close();
-  }
-
-  close(): void {
-    this._state = "Closed";
-  }
-
-  getXml(): string {
-    return this._xml;
-  }
-
   // Find existing prefix for a specified namespace
-  private getPrefixFromAncestors(ns: string): string | undefined {
-    for (const context of this._contextStack) {
+  function getPrefixFromAncestors(ns: string): string | undefined {
+    for (const context of contextStack) {
       for (const prefix of Object.keys(context.namespaces)) {
-        if (context.namespaces[prefix] === ns) return prefix;
+        if (context.namespaces[prefix] === ns) {
+          return prefix;
+        }
       }
     }
     return undefined;
   }
 
-  private peekContextStack(): XmlElementContext {
-    return this._contextStack[this._contextStack.length - 1];
-  }
-
-  private static generatePrefix(namespaces: XmlNamespaceDictionary): string {
-    let i = 1;
-    while (i < 100) {
-      if (!namespaces.hasOwnProperty("p" + i)) break;
-      i++;
-    }
-    return "p" + i;
-  }
-
-  private completeStartElement(close: boolean, namespaces: XmlNamespaceDictionary): void {
-    this.writeNamespaceAttributes(namespaces);
-    if (close) {
-      this.write(" />");
-    } else {
-      this.write(">");
-    }
-  }
-
-  private throwInvalidState(): void {
-    throw new Error(`Invalid state '${this._state}'.`);
-  }
-
-  private addNamespace(ns: string, prefix: string | undefined): void {
+  function addNamespace(ns: string, prefix: string | undefined): void {
     // Make sure we don't duplicate prefixes
-    prefix = prefix || "";
-    this.peekContextStack().namespaces[prefix] = ns;
+    peekContextStack().namespaces[prefix ?? ""] = ns;
   }
 
-  private writeIndent(newLine: boolean = true): void {
-    if (this._indent > 0) {
+  function writeIndent(newLine: boolean = true): void {
+    if (indentSize > 0) {
       if (newLine) {
-        this.write("\n");
+        write("\n");
       }
-      if (!(this._state === "Start" || this._state === "Prolog")) {
-        for (let i = 0; i < this._indent * (this._contextStack.length - 1); i++) {
-          this.write(" ");
+      if (!(state === "Start" || state === "Prolog")) {
+        for (let i = 0; i < indentSize * (contextStack.length - 1); i++) {
+          write(" ");
         }
       }
     }
   }
 
-  private write(text: string): void {
-    this._xml += text;
-    //console.log(`xml: '${this._xml}'`,);
-  }
-
-  private writeNamespaceAttributes(namespaces: XmlNamespaceDictionary): void {
-    // We should not repeat namespaces that exists in our ancestors
-    // Check which of our current namespaces that does not exist in this ancestor
-    const toWrite = this.getNamespacesNotInAncestors(namespaces);
-
-    // Write the ones that was not found in ancestor
-    for (const prefix of Object.keys(toWrite)) {
-      this.writeNamespaceAttribute(namespaces[prefix], prefix);
-    }
-  }
-
-  private getNamespacesNotInAncestors(namespaces: XmlNamespaceDictionary): XmlNamespaceDictionary {
+  function getNamespacesNotInAncestors(namespaces: XmlNamespaceDictionary): XmlNamespaceDictionary {
     const toWrite: XmlNamespaceDictionary = {};
     for (const prefix of Object.keys(namespaces)) {
       let exists: boolean = false;
       // Don't check the current (last) context in the stack
-      for (let i = 0; i < this._contextStack.length - 1; i++) {
-        const context = this._contextStack[i];
-        if (context.namespaces[prefix] == namespaces[prefix]) {
+      for (let i = 0; i < contextStack.length - 1; i++) {
+        const context = contextStack[i];
+        if (context.namespaces[prefix] === namespaces[prefix]) {
           exists = true;
           break;
         }
       }
-      if (!exists) toWrite[prefix] = namespaces[prefix];
+      if (!exists) {
+        toWrite[prefix] = namespaces[prefix];
+      }
     }
     return toWrite;
   }
 
-  private writeNamespaceAttribute(ns: string, prefix: string | undefined): void {
+  function writeNamespaceAttribute(ns: string, prefix: string | undefined): void {
     if (ns) {
       if (prefix) {
-        this.write(` xmlns:${prefix}="${ns}"`);
+        write(` xmlns:${prefix}="${ns}"`);
       } else {
-        this.write(` xmlns="${ns}"`);
+        write(` xmlns="${ns}"`);
       }
     }
   }
 
-  private static getPrefixedName(localName: string, prefix: string | undefined): string {
-    if (prefix) {
-      return `${prefix}:${localName}`;
+  function writeNamespaceAttributes(namespaces: XmlNamespaceDictionary): void {
+    // We should not repeat namespaces that exists in our ancestors
+    // Check which of our current namespaces that does not exist in this ancestor
+    const toWrite = getNamespacesNotInAncestors(namespaces);
+
+    // Write the ones that was not found in ancestor
+    for (const prefix of Object.keys(toWrite)) {
+      writeNamespaceAttribute(namespaces[prefix], prefix);
+    }
+  }
+
+  function completeStartElement(closeElement: boolean, namespaces: XmlNamespaceDictionary): void {
+    writeNamespaceAttributes(namespaces);
+    if (closeElement) {
+      write(" />");
     } else {
-      // oxlint-disable-next-line typescript/no-unnecessary-template-expression
-      return `${localName}`;
+      write(">");
     }
   }
+
+  const self: XmlWriter = {
+    WriteStartDocument(standalone?: boolean): void {
+      try {
+        if (state === "Start" || state === "Prolog") {
+          let bufBld: string = "";
+          bufBld += "version=" + quoteChar + "1.0" + quoteChar;
+          if (encoding !== null) {
+            bufBld += ` encoding=${quoteChar}${encoding}${quoteChar}`;
+          }
+          if (standalone) {
+            const standAlone = standalone ? "yes" : "no";
+            bufBld += ` standalone=${quoteChar}${standAlone}${quoteChar}`;
+          }
+          writeIndent(state !== "Start");
+          const xmlProcessingIntruction = `<?xml ${bufBld}?>`;
+          write(xmlProcessingIntruction);
+        } else {
+          throwInvalidState();
+        }
+        // Set next state
+        state = "Prolog";
+      } catch (e) {
+        state = "Error";
+        throw e;
+      }
+    },
+
+    WriteComment(text: string): void {
+      try {
+        if (state === "Prolog" || state === "Content") {
+          if (text && (text.indexOf("--") >= 0 || (text.length !== 0 && text.endsWith("-")))) {
+            throw new Error("Xml_InvalidCommentChars");
+          }
+          text = text || "";
+          writeIndent();
+          write(`<!--${text}-->`);
+        } else {
+          throwInvalidState();
+        }
+        // Set next state
+        // For XML-comments this case the next state should be the same as the previous one!
+      } catch (e) {
+        state = "Error";
+        throw e;
+      }
+    },
+
+    WriteStartElement(localName: string, ns?: string, prefix?: string): void {
+      try {
+        if (state === "Start" || state === "Prolog" || state === "Element" || state === "Content") {
+          if (state === "Element") {
+            // Close previous start-element
+            completeStartElement(false, peekContextStack().namespaces);
+          }
+
+          // Push new element-context to stack
+          const elementName: string = getPrefixedName(localName, prefix);
+          contextStack.push({
+            elementName,
+            namespaces: {},
+            contentStringWritten: false,
+          });
+
+          writeIndent(state !== "Start");
+          write("<" + elementName);
+
+          if (ns) {
+            addNamespace(ns, prefix);
+          }
+        } else {
+          throwInvalidState();
+        }
+        // Set next state
+        state = "Element";
+      } catch (e) {
+        state = "Error";
+        throw e;
+      }
+    },
+
+    WriteString(text: string): void {
+      try {
+        if (state === "Content" || state === "Element") {
+          if (state === "Element") {
+            completeStartElement(false, peekContextStack().namespaces);
+          }
+
+          // Flag that content string has been written
+          peekContextStack().contentStringWritten = true;
+
+          write(text);
+        } else {
+          throwInvalidState();
+        }
+        // Set next state
+        state = "Content";
+      } catch (e) {
+        state = "Error";
+        throw e;
+      }
+    },
+
+    WriteElementString(localName: string, value: string, ns: string, prefix: string): void {
+      self.WriteStartElement(localName, ns, prefix);
+      if (value && value.length > 0) {
+        self.WriteString(value);
+      }
+      self.WriteEndElement();
+    },
+
+    WriteAttributeString(localName: string, value: string, ns?: string, prefix?: string): void {
+      try {
+        if (state === "Element") {
+          if (ns) {
+            // Seems like a prefix is always invented for attributes if not provided
+            // (but for elements it is OK to have blank prefix)
+            if (!prefix || prefix.length === 0) {
+              prefix = getPrefixFromAncestors(ns);
+              // oxlint-disable-next-line typescript/prefer-nullish-coalescing -- an ancestor-registered blank prefix ("") must still be replaced here, per the comment above
+              if (!prefix) {
+                prefix = generatePrefix(peekContextStack().namespaces);
+              }
+            }
+            addNamespace(ns, prefix);
+          }
+          const attributeName: string = getPrefixedName(localName, prefix);
+          write(` ${attributeName}=${quoteChar}${value}${quoteChar}`);
+        } else {
+          throwInvalidState();
+        }
+        // Set next state
+        state = "Element";
+      } catch (e) {
+        state = "Error";
+        throw e;
+      }
+    },
+
+    WriteEndElement(): void {
+      try {
+        if (state === "Content" || state === "Element") {
+          const context = peekContextStack();
+          // Only close in itself if no content
+          if (state === "Element") {
+            completeStartElement(true, context.namespaces);
+          } else {
+            // Do not indent if there is text content written since
+            // the indention would be included in the actual text content
+            if (!context.contentStringWritten) {
+              writeIndent();
+            }
+            write(`</${context.elementName}>`);
+          }
+          contextStack.pop();
+        } else {
+          throwInvalidState();
+        }
+        // Set next state
+        if (contextStack.length === 0) {
+          state = "Closed";
+        } else {
+          state = "Content";
+        }
+      } catch (e) {
+        state = "Error";
+        throw e;
+      }
+    },
+
+    Flush(): void {
+      self.close();
+    },
+
+    close(): void {
+      state = "Closed";
+    },
+
+    getXml(): string {
+      return xml;
+    },
+  };
+
+  return self;
 }