oozcitak

xmlbuilder

All notable changes to this project are documented in this file. This project adheres to [Semantic Versioning](http://semver.org/#semantic-versioning-200).

- Removed support for node.js 6.0\. Minimum required version is now 8.0.

- Fixed a bug where importing a document into an empty parent document did not set the root node. See [#213](https://github.com/oozcitak/xmlbuilder-js/issues/213).

- Corrected typings for doctype and character data nodes. See [#211](https://github.com/oozcitak/xmlbuilder-js/issues/211).

- Rewrote all TypeSript typings to be strictly compatible with the API. This is a breaking change for TypeScript users only.

- Added option for pretty printing attributes.

- Removed support for node.js 4.0 and 5.0\. Minimum required version is now 6.0.

- Added TypeScript typings. See [#200](https://github.com/oozcitak/xmlbuilder-js/issues/200).

- Calling `end()` with arguments no longer overwrites writer options. See [#120](https://github.com/oozcitak/xmlbuilder-js/issues/120).

- Added writer state and customizable space and endline functions to help customize writer behavior. Also added `openNode` and `closeNode` functions to writer. See [#193](https://github.com/oozcitak/xmlbuilder-js/issues/193).

- Fixed a bug where writer functions would not be called for nodes with a single child node in pretty print mode. See [#195](https://github.com/oozcitak/xmlbuilder-js/issues/195).

- Renamed `elEscape` to `textEscape` in `XMLStringifier`.

- Fixed a bug where empty arrays would produce child nodes. See [#190](https://github.com/oozcitak/xmlbuilder-js/issues/190).

- Removed the `skipNullAttributes` option. `null` attributes are now skipped by default. Added the `keepNullAttributes` option in case someone needs the old behavior.

- Removed the `skipNullNodes` option. `null` nodes are now skipped by default. Added the `keepNullNodes` option in case someone needs the old behavior.

- `undefined` values are now skipped when converting JS objects.

- Renamed stringify functions. See [#194](https://github.com/oozcitak/xmlbuilder-js/issues/194):

- Fixed argument order for `attribute` function in the writer. See [#196](https://github.com/oozcitak/xmlbuilder-js/issues/196).

- Added `openAttribute` and `closeAttribute` functions to writer. See [#196](https://github.com/oozcitak/xmlbuilder-js/issues/196).

- Added node types to node objects. Node types and writer states are exported by the module with the `nodeType` and `writerState` properties.

- Fixed a bug where array items would not be correctly converted. See [#159](https://github.com/oozcitak/xmlbuilder-js/issues/159).

- Fixed a bug where mixed-content inside JS objects with `#text` decorator would not be correctly converted. See [#171](https://github.com/oozcitak/xmlbuilder-js/issues/171).

- Fixed a bug where JS objects would not be expanded in callback mode. See [#173](https://github.com/oozcitak/xmlbuilder-js/issues/173).

- Fixed a bug where character validation would not obey document's XML version. Added separate validation for XML 1.0 and XML 1.1 documents. See [#169](https://github.com/oozcitak/xmlbuilder-js/issues/169).

- Fixed a bug where names would not be validated according to the spec. See [#49](https://github.com/oozcitak/xmlbuilder-js/issues/49).

- Renamed `text` property to `value` in comment and cdata nodes to unify the API.

- Removed `doctype` function to prevent name clash with DOM implementation. Use the `dtd` function instead.

- Removed dummy nodes from the XML tree (Those were created while chain-building the tree).

- Renamed `attributes`property to `attribs` to prevent name clash with DOM property with the same name.

- Implemented the DOM standard (read-only) to support XPath lookups. XML namespaces are not currently supported. See [#122](https://github.com/oozcitak/xmlbuilder-js/issues/122).

- Fixed an edge case where a null node at root level would be printed although `skipNullNodes` was set. See [#187](https://github.com/oozcitak/xmlbuilder-js/issues/187).

- Added the `skipNullNodes` option to skip nodes with null values. See [#158](https://github.com/oozcitak/xmlbuilder-js/issues/158).

- Added current indentation level as a parameter to the onData function when in callback mode. See [#125](https://github.com/oozcitak/xmlbuilder-js/issues/125).

- Added name of the current node and parent node to error messages where possible. See [#152](https://github.com/oozcitak/xmlbuilder-js/issues/152). This has the potential to break code depending on the content of error messages.

- Fixed an issue where objects created with Object.create(null) created an error. See [#176](https://github.com/oozcitak/xmlbuilder-js/issues/176).

- Added test builds for node.js v8 and v10.

- Simplified regex used for validating encoding.

- `spacebeforeslash` writer option accepts `true` as well as space char(s).

- `spacebeforeslash` writer option can now be used with XML fragments.

- Added the `spacebeforeslash` writer option to add a space character before closing tags of empty elements. See [#157](https://github.com/oozcitak/xmlbuilder-js/issues/157).

- Fixed character validity checks to work with node.js 4.0 and 5.0\. See [#161](https://github.com/oozcitak/xmlbuilder-js/issues/161).

- Fixed valid char filter to use XML 1.1 instead of 1.0\. See [#147](https://github.com/oozcitak/xmlbuilder-js/issues/147).

- Added options for negative indentation and suppressing pretty printing of text nodes. See [#145](https://github.com/oozcitak/xmlbuilder-js/issues/145).

- Falsy values can now be used as a text node in callback mode.

[13.0.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v13.0.1...v13.0.2

[14.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v13.0.2...v14.0.0

  module.exports = XMLStringifier = (function() {

      // Initializes a new instance of `XMLStringifier`

      // `options.version` The version number string of the XML spec to validate against, e.g. 1.0

      // `options.noDoubleEncoding` whether existing html entities are encoded: true or false

      // `options.stringify` a set of functions to use for converting values to strings

      // `options.noValidation` whether values will be validated and escaped or returned as is

        // Checks whether the given string contains legal characters

        // Fails with an exception on error

        this.assertLegalChar = this.assertLegalChar.bind(this);

        // Checks whether the given string contains legal characters for a name

        this.assertLegalName = this.assertLegalName.bind(this);

          if (!hasProp.call(ref, key)) continue;

        return this.assertLegalName('' + val || '');

        return this.assertLegalChar(this.textEscape('' + val || ''));

        val = val.replace(']]>', ']]]]><![CDATA[>');

        return this.assertLegalChar(val);

          throw new Error("Comment text cannot contain double-hypen: " + val);

        return this.assertLegalChar(this.attEscape(val = '' + val || ''));

        return this.assertLegalChar('' + val || '');

          throw new Error("Invalid character in name");

          throw new Error(`Invalid character in name: ${str}`);

      // Escapes special characters in text

      // See http://www.w3.org/TR/2000/WD-xml-c14n-20000119.html#charescaping

        ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;

        return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\r/g, '&#xD;');

      // Escapes special characters in attribute values

        return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;').replace(/\t/g, '&#x9;').replace(/\n/g, '&#xA;').replace(/\r/g, '&#xD;');

    // strings to match while converting from JS objects

    XMLStringifier.prototype.convertAttKey = '@';

    XMLStringifier.prototype.convertPIKey = '?';

    XMLStringifier.prototype.convertTextKey = '#text';

    XMLStringifier.prototype.convertCDataKey = '#cdata';

    XMLStringifier.prototype.convertCommentKey = '#comment';

    XMLStringifier.prototype.convertRawKey = '#raw';

  var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign,

  XMLDeclaration = require('./XMLDeclaration');

  XMLProcessingInstruction = require('./XMLProcessingInstruction');

  XMLDTDAttList = require('./XMLDTDAttList');

  XMLDTDElement = require('./XMLDTDElement');

  XMLDTDEntity = require('./XMLDTDEntity');

  XMLDTDNotation = require('./XMLDTDNotation');

  WriterState = require('./WriterState');

  module.exports = XMLWriterBase = class XMLWriterBase {

    // Initializes a new instance of `XMLWriterBase`

    // `options.pretty` pretty prints the result

    // `options.indent` indentation string

    // `options.newline` newline sequence

    // `options.offset` a fixed number of indentations to add to every line

    // `options.width` maximum column width

    // `options.allowEmpty` do not self close empty element tags

    // 'options.dontPrettyTextNodes' if any text is present in node, don't indent or LF

    // `options.spaceBeforeSlash` add a space before the closing slash of empty elements

        if (!hasProp.call(ref, key)) continue;

    // Filters writer options and provides defaults

      var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7;

      options = assign({}, this.options, options);

      filteredOptions.pretty = options.pretty || false;

      filteredOptions.allowEmpty = options.allowEmpty || false;

      filteredOptions.indent = (ref = options.indent) != null ? ref : '  ';

      filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : '\n';

      filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;

      filteredOptions.width = (ref3 = options.width) != null ? ref3 : 0;

      filteredOptions.dontPrettyTextNodes = (ref4 = (ref5 = options.dontPrettyTextNodes) != null ? ref5 : options.dontprettytextnodes) != null ? ref4 : 0;

      filteredOptions.spaceBeforeSlash = (ref6 = (ref7 = options.spaceBeforeSlash) != null ? ref7 : options.spacebeforeslash) != null ? ref6 : '';

      if (filteredOptions.spaceBeforeSlash === true) {

        filteredOptions.spaceBeforeSlash = ' ';

      filteredOptions.suppressPrettyCount = 0;

      filteredOptions.state = WriterState.None;

    // Returns the indentation string for the current level

      if (!options.pretty || options.suppressPrettyCount) {

        indentLevel = (level || 0) + options.offset + 1;

      if (childNodeCount === 0 || node.children.every(function(e) {

        return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === '';

        return (e.type === NodeType.Text || e.type === NodeType.Raw || e.type === NodeType.CData) && e.value === '';

          options.state = WriterState.CloseTag;

          r += '</' + node.name + '>' + this.endline(node, options, level);

          r += options.spaceBeforeSlash + '/>' + this.endline(node, options, level);

      } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {

      } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw || firstChildNode.type === NodeType.CData) && (firstChildNode.value != null)) {

        options.state = WriterState.InsideTag;

        r += this.writeChildNode(firstChildNode, options, level + 1);

        options.state = WriterState.CloseTag;

        r += '</' + node.name + '>' + this.endline(node, options, level);

        // if ANY are a text node, then suppress pretty now

        if (options.dontPrettyTextNodes) {

          for (i = 0, len1 = ref2.length; i < len1; i++) {

            if ((child.type === NodeType.Text || child.type === NodeType.Raw) && (child.value != null)) {

            if ((child.type === NodeType.Text || child.type === NodeType.Raw || child.type === NodeType.CData) && (child.value != null)) {

              options.suppressPrettyCount++;

        // close the opening tag, after dealing with newline

        r += '>' + this.endline(node, options, level);

        for (j = 0, len2 = ref3.length; j < len2; j++) {

          r += this.writeChildNode(child, options, level + 1);

        r += this.indent(node, options, level) + '</' + node.name + '>';

        r += this.endline(node, options, level);

        options.state = WriterState.None;

      this.closeNode(node, options, level);

    writeChildNode(node, options, level) {

          return this.cdata(node, options, level);

          return this.comment(node, options, level);

          return this.element(node, options, level);

          return this.raw(node, options, level);

          return this.text(node, options, level);

        case NodeType.ProcessingInstruction:

          return this.processingInstruction(node, options, level);

          return this.declaration(node, options, level);

          return this.docType(node, options, level);

        case NodeType.AttributeDeclaration:

          return this.dtdAttList(node, options, level);

        case NodeType.ElementDeclaration:

          return this.dtdElement(node, options, level);

          return this.dtdEntity(node, options, level);

        case NodeType.NotationDeclaration:

          return this.dtdNotation(node, options, level);

          throw new Error("Unknown XML node type: " + node.constructor.name);

    processingInstruction(node, options, level) {

      this.openNode(node, options, level);

      options.state = WriterState.OpenTag;

      r = this.indent(node, options, level) + '<?';

      options.state = WriterState.InsideTag;

      options.state = WriterState.CloseTag;

      r += options.spaceBeforeSlash + '?>';

      r += this.endline(node, options, level);

      r = this.indent(node, options, level);

  "homepage": "http://github.com/oozcitak/xmlbuilder-js",

  "description": "An XML builder for node.js",

  "author": "Ozgur Ozcitak <oozcitak@gmail.com>",

    "url": "git://github.com/oozcitak/xmlbuilder-js.git"

    "url": "http://github.com/oozcitak/xmlbuilder-js/issues"

      "coffee-coverage/register-istanbul",

    "prepublishOnly": "coffee -co lib src",

    "test": "nyc mocha \"test/**/*.coffee\"",

		@@ -5,2 +5,6 @@ # Change Log

		## [14.0.0] - 2020-02-14

		- Removed support for node.js 6.0\. Minimum required version is now 8.0.

		## [13.0.2] - 2019-05-22
		@@ -570,1 +574,2 @@
		[13.0.2]: https://github.com/oozcitak/xmlbuilder-js/compare/v13.0.1...v13.0.2
		[14.0.0]: https://github.com/oozcitak/xmlbuilder-js/compare/v13.0.2...v14.0.0

		@@ -235,3 +235,3 @@ // Generated by CoffeeScript 2.4.1
		if (!str.match(regex)) {
		throw new Error("Invalid character in name");
		throw new Error(`Invalid character in name: ${str}`);
		}
		@@ -238,0 +238,0 @@ return str;

		{
		"name": "xmlbuilder",
		"version": "14.0.0",
		"version": "15.0.0",
		"keywords": [
		@@ -5,0 +5,0 @@ "xml",

		@@ -255,3 +255,3 @@ // Generated by CoffeeScript 2.4.1
		if (childNodeCount === 0 \|\| node.children.every(function(e) {
		return (e.type === NodeType.Text \|\| e.type === NodeType.Raw) && e.value === '';
		return (e.type === NodeType.Text \|\| e.type === NodeType.Raw \|\| e.type === NodeType.CData) && e.value === '';
		})) {
		@@ -267,3 +267,3 @@ // empty element
		}
		} else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text \|\| firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {
		} else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text \|\| firstChildNode.type === NodeType.Raw \|\| firstChildNode.type === NodeType.CData) && (firstChildNode.value != null)) {
		// do not indent text-only nodes
		@@ -285,3 +285,3 @@ r += '>';
		child = ref2[i];
		if ((child.type === NodeType.Text \|\| child.type === NodeType.Raw) && (child.value != null)) {
		if ((child.type === NodeType.Text \|\| child.type === NodeType.Raw \|\| child.type === NodeType.CData) && (child.value != null)) {
		options.suppressPrettyCount++;
		@@ -288,0 +288,0 @@ prettySuppressed = true;

Improved metrics